diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/Canonicals.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/Canonicals.java index 17499205f..49f914a13 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/Canonicals.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/Canonicals.java @@ -134,7 +134,7 @@ public static > String getUrl(Canon public static String getUrl(String canonical) { checkNotNull(canonical); - if (!canonical.contains("/")) { + if (!canonical.contains("/") && !canonical.startsWith("urn:uuid") && !canonical.startsWith("urn:oid")) { return null; } diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/Constants.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/Constants.java index a0c0f0246..3796e3b7f 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/Constants.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/Constants.java @@ -60,6 +60,7 @@ private Constants() {} public static final String CPG_CUSTOM_ACTIVITY_KIND = "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-custom-activity-kind"; public static final String CPG_ACTIVITY_KIND = "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-activity-kind"; + public static final String CQF_RESOURCETYPE = "http://hl7.org/fhir/StructureDefinition/cqf-resourceType"; // DSTU3 CQF Extensions public static final String CQIF_LIBRARY = "http://hl7.org/fhir/StructureDefinition/cqif-library"; diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/SearchHelper.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/SearchHelper.java index b3095c6e8..135580eb1 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/SearchHelper.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/SearchHelper.java @@ -4,15 +4,21 @@ import ca.uhn.fhir.model.api.IQueryParameterType; import ca.uhn.fhir.parser.DataFormatException; +import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException; import java.util.Collections; import java.util.List; import java.util.Map; +import java.util.Optional; +import java.util.stream.Collectors; +import org.apache.commons.lang3.StringUtils; import org.hl7.fhir.exceptions.FHIRException; import org.hl7.fhir.instance.model.api.IBaseBundle; +import org.hl7.fhir.instance.model.api.IBaseExtension; import org.hl7.fhir.instance.model.api.IBaseResource; import org.hl7.fhir.instance.model.api.IIdType; import org.hl7.fhir.instance.model.api.IPrimitiveType; import org.opencds.cqf.fhir.api.Repository; +import org.opencds.cqf.fhir.utility.adapter.IDependencyInfo; import org.opencds.cqf.fhir.utility.search.Searches; public class SearchHelper { @@ -72,21 +78,39 @@ public static > IBaseResource searc * @param canonical the canonical url to search for * @return */ - private static > Class getResourceType( + public static > Class getResourceType( Repository repository, CanonicalType canonical) { Class resourceType = null; try { + var resourceTypeString = Canonicals.getResourceType(canonical); + if (StringUtils.isEmpty(resourceTypeString)) { + throw new DataFormatException(); + } resourceType = repository .fhirContext() - .getResourceDefinition(Canonicals.getResourceType(canonical)) + .getResourceDefinition(resourceTypeString) .getImplementingClass(); } catch (DataFormatException e) { - // TODO: Use the "cqf-resourceType" extension to figure this out, if it's present - // NOTE: This is based on the assumption that only CodeSystems don't follow the canonical pattern... - resourceType = - repository.fhirContext().getResourceDefinition("CodeSystem").getImplementingClass(); + // Use the "cqf-resourceType" extension to figure this out, if it's present + var cqfResourceTypeExt = getResourceTypeStringFromCqfResourceTypeExtension(canonical); + if (cqfResourceTypeExt.isPresent()) { + try { + resourceType = repository + .fhirContext() + .getResourceDefinition(cqfResourceTypeExt.get()) + .getImplementingClass(); + } catch (DataFormatException | NullPointerException e2) { + throw new UnprocessableEntityException( + "cqf-resourceType extension contains invalid resource type: " + cqfResourceTypeExt.get()); + } + } else { + // NOTE: This is based on the assumption that only CodeSystems don't follow the canonical pattern... + resourceType = repository + .fhirContext() + .getResourceDefinition("CodeSystem") + .getImplementingClass(); + } } - return resourceType; } @@ -100,6 +124,85 @@ private static > Class + * @param repository the repository to search + * @param dependencyInfo the canonical url to search for + * @return + */ + public static Class getResourceType( + Repository repository, IDependencyInfo dependencyInfo) { + Class resourceType = null; + try { + var resourceTypeString = Canonicals.getResourceType(dependencyInfo.getReference()); + if (StringUtils.isEmpty(resourceTypeString)) { + throw new DataFormatException(); + } + resourceType = repository + .fhirContext() + .getResourceDefinition(resourceTypeString) + .getImplementingClass(); + } catch (DataFormatException e) { + // Use the "cqf-resourceType" extension to figure this out, if it's present + var cqfResourceTypeExt = getResourceTypeStringFromCqfResourceTypeExtension(dependencyInfo.getExtension()); + if (cqfResourceTypeExt.isPresent()) { + try { + resourceType = repository + .fhirContext() + .getResourceDefinition(cqfResourceTypeExt.get()) + .getImplementingClass(); + } catch (DataFormatException | NullPointerException e2) { + throw new UnprocessableEntityException( + "cqf-resourceType extension contains invalid resource type: " + cqfResourceTypeExt.get()); + } + } else { + // NOTE: This is based on the assumption that only CodeSystems don't follow the canonical pattern... + resourceType = repository + .fhirContext() + .getResourceDefinition("CodeSystem") + .getImplementingClass(); + } + } + return resourceType; + } + + private static > + Optional getResourceTypeStringFromCqfResourceTypeExtension(CanonicalType canonical) { + return getResourceTypeStringFromCqfResourceTypeExtension(getExtensions(canonical)); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + private static Optional getResourceTypeStringFromCqfResourceTypeExtension( + List extensions) { + return extensions.stream() + .filter(ext -> ext.getUrl().contains("cqf-resourceType")) + .findAny() + .map(ext -> ((IPrimitiveType) ext.getValue()).getValue()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + private static > List getExtensions( + CanonicalType canonical) { + if (canonical instanceof org.hl7.fhir.dstu3.model.PrimitiveType) { + return ((org.hl7.fhir.dstu3.model.PrimitiveType) canonical) + .getExtension().stream().map(ext -> (IBaseExtension) ext).collect(Collectors.toList()); + } else if (canonical instanceof org.hl7.fhir.r4.model.PrimitiveType) { + return ((org.hl7.fhir.r4.model.PrimitiveType) canonical) + .getExtension().stream().map(ext -> (IBaseExtension) ext).collect(Collectors.toList()); + } else if (canonical instanceof org.hl7.fhir.r5.model.PrimitiveType) { + return ((org.hl7.fhir.r5.model.PrimitiveType) canonical) + .getExtension().stream().map(ext -> (IBaseExtension) ext).collect(Collectors.toList()); + } else { + throw new UnprocessableEntityException("Unsupported FHIR version for canonical: " + canonical.getValue()); + } + } + + /** + * Gets the resource type for the given canonical, based on the convention that canonical + * URLs are of the form [base]/[resourceType]/[tail] + * + * If the URL does not conform to the convention, the type of the canonical is assumed to be CodeSystem, on + * the grounds that most (if not all) non-conventional URLs are for CodeSystem uris. + * * @param repository * @param canonical * @return @@ -112,7 +215,7 @@ private static Class getResourceType(Repository reposit .getResourceDefinition(Canonicals.getResourceType(canonical)) .getImplementingClass(); } catch (RuntimeException e) { - // TODO: Use the "cqf-resourceType" extension to figure this out, if it's present + // Can't use the "cqf-resourceType" extension to figure this out because we just get a canonical string // NOTE: This is based on the assumption that only CodeSystems don't follow the canonical pattern... resourceType = repository.fhirContext().getResourceDefinition("CodeSystem").getImplementingClass(); @@ -177,6 +280,21 @@ public static > IBaseBundle searchR return searchRepositoryByCanonicalWithPaging(repository, canonical, resourceType); } + /** + * Searches the given Repository and handles paging to return all entries + * + * @param additionalSearchParams search parameters to pass on to the repository + * @param repository the repository to search + * @param canonical the canonical url to search for + * @return + */ + public static IBaseBundle searchRepositoryByCanonicalWithPagingWithParams( + Repository repository, String canonical, Map> additionalSearchParams) { + var resourceType = getResourceType(repository, canonical); + return searchRepositoryByCanonicalWithPagingWithParams( + repository, canonical, resourceType, additionalSearchParams); + } + /** * Searches the given Repository and handles paging to return all entries * @@ -190,9 +308,32 @@ public static > IBaseBundle searchR public static , R extends IBaseResource> IBaseBundle searchRepositoryByCanonicalWithPaging( Repository repository, CanonicalType canonical, Class resourceType) { + return searchRepositoryByCanonicalWithPagingWithParams(repository, canonical, resourceType, null); + } + + /** + * Searches the given Repository and handles paging to return all entries + * + * @param an IPrimitiveType type + * @param an IBaseResource type + * @param repository the repository to search + * @param canonical the canonical url to search for + * @param resourceType the class of the IBaseResource type + * @param additionalSearchParams extra search parameters to search with + * @return + */ + public static , R extends IBaseResource> + IBaseBundle searchRepositoryByCanonicalWithPagingWithParams( + Repository repository, + CanonicalType canonical, + Class resourceType, + Map> additionalSearchParams) { var url = Canonicals.getUrl(canonical); var version = Canonicals.getVersion(canonical); var searchParams = version == null ? Searches.byUrl(url) : Searches.byUrlAndVersion(url, version); + if (additionalSearchParams != null) { + searchParams.putAll(additionalSearchParams); + } var searchResult = searchRepositoryWithPaging(repository, resourceType, searchParams, Collections.emptyMap()); return searchResult; @@ -209,9 +350,30 @@ IBaseBundle searchRepositoryByCanonicalWithPaging( */ public static IBaseBundle searchRepositoryByCanonicalWithPaging( Repository repository, String canonical, Class resourceType) { + return searchRepositoryByCanonicalWithPagingWithParams(repository, canonical, resourceType, null); + } + + /** + * Searches the given Repository and handles paging to return all entries + * + * @param an IBaseResource type + * @param repository the repository to search + * @param canonical the canonical url to search for + * @param resourceType the class of the IBaseResource type + * @param additionalSearchParams extra search parameters to search with + * @return + */ + public static IBaseBundle searchRepositoryByCanonicalWithPagingWithParams( + Repository repository, + String canonical, + Class resourceType, + Map> additionalSearchParams) { var url = Canonicals.getUrl(canonical); var version = Canonicals.getVersion(canonical); var searchParams = version == null ? Searches.byUrl(url) : Searches.byUrlAndVersion(url, version); + if (additionalSearchParams != null) { + searchParams.putAll(additionalSearchParams); + } var searchResult = searchRepositoryWithPaging(repository, resourceType, searchParams, Collections.emptyMap()); return searchResult; diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/KnowledgeArtifactAdapter.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/KnowledgeArtifactAdapter.java index 5e0de4c0d..413939b19 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/KnowledgeArtifactAdapter.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/KnowledgeArtifactAdapter.java @@ -310,6 +310,7 @@ static boolean isSupportedMetadataResource(IBaseResource resource) { || resource instanceof org.hl7.fhir.r5.model.MetadataResource; } + // TODO: Make this a semver sort static Optional findLatestVersion(IBaseBundle bundle) { var sorted = BundleHelper.getEntryResources(bundle).stream() .filter(r -> isSupportedMetadataResource(r)) @@ -324,6 +325,10 @@ static Optional findLatestVersion(IBaseBundle bundle) { } } + default Optional getExpansionParameters() { + return Optional.empty(); + } + String releaseLabelUrl = "http://hl7.org/fhir/StructureDefinition/artifact-releaseLabel"; String releaseDescriptionUrl = "http://hl7.org/fhir/StructureDefinition/artifact-releaseDescription"; String usPhContextTypeUrl = "http://hl7.org/fhir/us/ecr/CodeSystem/us-ph-usage-context-type"; diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/LibraryAdapter.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/LibraryAdapter.java index 591050b8b..9193b0fee 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/LibraryAdapter.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/LibraryAdapter.java @@ -31,4 +31,7 @@ public interface LibraryAdapter extends KnowledgeArtifactAdapter { LibraryAdapter setDataRequirement(List dataRequirement); List getUseContext(); + + void setExpansionParameters( + List systemVersionExpansionParameters, List canonicalVersionExpansionParameters); } diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/dstu3/LibraryAdapter.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/dstu3/LibraryAdapter.java index 73989dcf0..06ed199cc 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/dstu3/LibraryAdapter.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/dstu3/LibraryAdapter.java @@ -3,16 +3,23 @@ import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException; import java.util.ArrayList; import java.util.List; +import java.util.Optional; import java.util.stream.Collectors; import org.hl7.fhir.dstu3.model.Attachment; import org.hl7.fhir.dstu3.model.CodeableConcept; import org.hl7.fhir.dstu3.model.Coding; import org.hl7.fhir.dstu3.model.DataRequirement; import org.hl7.fhir.dstu3.model.Library; +import org.hl7.fhir.dstu3.model.Parameters; +import org.hl7.fhir.dstu3.model.Parameters.ParametersParameterComponent; +import org.hl7.fhir.dstu3.model.Reference; import org.hl7.fhir.dstu3.model.RelatedArtifact; +import org.hl7.fhir.dstu3.model.UriType; import org.hl7.fhir.dstu3.model.UsageContext; +import org.hl7.fhir.instance.model.api.IBaseParameters; import org.hl7.fhir.instance.model.api.ICompositeType; import org.hl7.fhir.instance.model.api.IDomainResource; +import org.opencds.cqf.fhir.utility.Constants; import org.opencds.cqf.fhir.utility.adapter.DependencyInfo; import org.opencds.cqf.fhir.utility.adapter.IDependencyInfo; @@ -141,4 +148,58 @@ public LibraryAdapter setDataRequirement(List data public List getUseContext() { return getLibrary().getUseContext(); } + + @Override + public Optional getExpansionParameters() { + return getLibrary().getExtension().stream() + .filter(ext -> ext.getUrl().equals(Constants.CQF_EXPANSION_PARAMETERS)) + .findAny() + .map(ext -> ((Reference) ext.getValue()).getReference()) + .map(ref -> { + if (getLibrary().hasContained()) { + return getLibrary().getContained().stream() + .filter(containedResource -> + containedResource.getId().equals(ref)) + .findFirst() + .map(r -> (IBaseParameters) r) + .orElse(null); + } + return null; + }); + } + + @Override + public void setExpansionParameters( + List systemVersionExpansionParameters, List canonicalVersionExpansionParameters) { + var newParameters = new ArrayList(); + if (systemVersionExpansionParameters != null && !systemVersionExpansionParameters.isEmpty()) { + for (String parameter : systemVersionExpansionParameters) { + var param = new ParametersParameterComponent(); + param.setName("system-version"); + param.setValue(new UriType(parameter)); + newParameters.add(param); + } + } + if (canonicalVersionExpansionParameters != null && !canonicalVersionExpansionParameters.isEmpty()) { + for (String parameter : canonicalVersionExpansionParameters) { + var param = new ParametersParameterComponent(); + param.setName("canonical-version"); + param.setValue(new UriType(parameter)); + newParameters.add(param); + } + } + var existingExpansionParameters = getExpansionParameters(); + if (existingExpansionParameters.isPresent()) { + ((Parameters) existingExpansionParameters.get()).setParameter(newParameters); + } else { + var id = "#exp-params"; + var newExpansionParameters = new Parameters(); + newExpansionParameters.setParameter(newParameters); + newExpansionParameters.setId(id); + getLibrary().addContained(newExpansionParameters); + var expansionParamsExt = getLibrary().addExtension(); + expansionParamsExt.setUrl(Constants.CQF_EXPANSION_PARAMETERS); + expansionParamsExt.setValue(new Reference(id)); + } + } } diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/dstu3/MeasureAdapter.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/dstu3/MeasureAdapter.java index e266d4c22..79f0d59a6 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/dstu3/MeasureAdapter.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/dstu3/MeasureAdapter.java @@ -2,11 +2,15 @@ import java.util.ArrayList; import java.util.List; +import java.util.Optional; +import java.util.function.Consumer; import java.util.stream.Collectors; +import org.hl7.fhir.dstu3.model.Extension; import org.hl7.fhir.dstu3.model.Library; import org.hl7.fhir.dstu3.model.Measure; import org.hl7.fhir.dstu3.model.Reference; import org.hl7.fhir.dstu3.model.RelatedArtifact; +import org.hl7.fhir.dstu3.model.UriType; import org.hl7.fhir.instance.model.api.IDomainResource; import org.opencds.cqf.fhir.utility.Constants; import org.opencds.cqf.fhir.utility.adapter.DependencyInfo; @@ -44,18 +48,34 @@ public Measure copy() { private Library effectiveDataRequirements; private LibraryAdapter effectiveDataRequirementsAdapter; + private String getEdrReferenceString(Extension edrExtension) { + return edrExtension.getUrl().contains("cqfm") + ? ((Reference) edrExtension.getValue()).getReference() + : ((UriType) edrExtension.getValue()).getValue(); + } + + private Consumer getEdrReferenceConsumer(Extension edrExtension) { + return edrExtension.getUrl().contains("cqfm") + ? (reference) -> edrExtension.setValue(new Reference(reference)) + : (reference) -> edrExtension.setValue(new UriType(reference)); + } + private void findEffectiveDataRequirements() { if (!checkedEffectiveDataRequirements) { - var edrExtensions = this.getMeasure().getExtension().stream() + List edrExtensions = this.getMeasure().getExtension().stream() .filter(ext -> ext.getUrl().endsWith("-effectiveDataRequirements")) .filter(ext -> ext.hasValue()) .collect(Collectors.toList()); var edrExtension = edrExtensions.size() == 1 ? edrExtensions.get(0) : null; - if (edrExtension != null) { - var edrReference = ((Reference) edrExtension.getValue()).getReference(); + // cqfm-effectiveDataRequirements is a Reference, crmi-effectiveDataRequirements is a canonical + var maybeEdrReference = Optional.ofNullable(edrExtension).map(e -> getEdrReferenceString(e)); + if (maybeEdrReference.isPresent()) { + var edrReference = maybeEdrReference.get(); for (var c : getMeasure().getContained()) { - if (c.hasId() && String.format("#%s", c.getId()).equals(edrReference) && c instanceof Library) { + if (c.hasId() + && (edrReference.equals(c.getId()) || edrReference.equals("#" + c.getId())) + && c instanceof Library) { effectiveDataRequirements = (Library) c; effectiveDataRequirementsAdapter = new LibraryAdapter(effectiveDataRequirements); } @@ -102,7 +122,7 @@ public List getDependencies() { // library[] for (var library : getMeasure().getLibrary()) { - DependencyInfo dependency = new DependencyInfo( + final var dependency = new DependencyInfo( referenceSource, library.getReference(), library.getExtension(), @@ -116,9 +136,9 @@ public List getDependencies() { .filter(e -> CANONICAL_EXTENSIONS.contains(e.getUrl())) .forEach(referenceExt -> references.add(new DependencyInfo( referenceSource, - ((Reference) referenceExt.getValue()).getReference(), + getEdrReferenceString(referenceExt), referenceExt.getExtension(), - (reference) -> referenceExt.setValue(new Reference(reference))))); + getEdrReferenceConsumer(referenceExt)))); // extension[cqfm-inputParameters][] // extension[cqfm-expansionParameters][] diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r4/LibraryAdapter.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r4/LibraryAdapter.java index a89feaccb..e3656e479 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r4/LibraryAdapter.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r4/LibraryAdapter.java @@ -3,7 +3,9 @@ import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException; import java.util.ArrayList; import java.util.List; +import java.util.Optional; import java.util.stream.Collectors; +import org.hl7.fhir.instance.model.api.IBaseParameters; import org.hl7.fhir.instance.model.api.ICompositeType; import org.hl7.fhir.instance.model.api.IDomainResource; import org.hl7.fhir.r4.model.Attachment; @@ -11,8 +13,13 @@ import org.hl7.fhir.r4.model.Coding; import org.hl7.fhir.r4.model.DataRequirement; import org.hl7.fhir.r4.model.Library; +import org.hl7.fhir.r4.model.Parameters; +import org.hl7.fhir.r4.model.Parameters.ParametersParameterComponent; +import org.hl7.fhir.r4.model.Reference; import org.hl7.fhir.r4.model.RelatedArtifact; +import org.hl7.fhir.r4.model.UriType; import org.hl7.fhir.r4.model.UsageContext; +import org.opencds.cqf.fhir.utility.Constants; import org.opencds.cqf.fhir.utility.adapter.DependencyInfo; import org.opencds.cqf.fhir.utility.adapter.IDependencyInfo; @@ -78,6 +85,7 @@ public List getDependencies() { .map(ra -> DependencyInfo.convertRelatedArtifact(ra, referenceSource)) .forEach(ra -> references.add(ra)); getLibrary().getDataRequirement().stream().forEach(dr -> { + // dataRequirement[].profile[] dr.getProfile().stream() .filter(profile -> profile.hasValue()) .forEach(profile -> references.add(new DependencyInfo( @@ -85,6 +93,7 @@ public List getDependencies() { profile.getValue(), profile.getExtension(), (reference) -> profile.setValue(reference)))); + // dataRequirement[].codeFilter[].valueSet dr.getCodeFilter().stream() .filter(cf -> cf.hasValueSet()) .forEach(cf -> references.add(new DependencyInfo( @@ -141,4 +150,58 @@ public LibraryAdapter setDataRequirement(List data public List getUseContext() { return getLibrary().getUseContext(); } + + @Override + public Optional getExpansionParameters() { + return getLibrary().getExtension().stream() + .filter(ext -> ext.getUrl().equals(Constants.CQF_EXPANSION_PARAMETERS)) + .findAny() + .map(ext -> ((Reference) ext.getValue()).getReference()) + .map(ref -> { + if (getLibrary().hasContained()) { + return getLibrary().getContained().stream() + .filter(containedResource -> + containedResource.getId().equals(ref)) + .findFirst() + .map(r -> (IBaseParameters) r) + .orElse(null); + } + return null; + }); + } + + @Override + public void setExpansionParameters( + List systemVersionExpansionParameters, List canonicalVersionExpansionParameters) { + var newParameters = new ArrayList(); + if (systemVersionExpansionParameters != null && !systemVersionExpansionParameters.isEmpty()) { + for (String parameter : systemVersionExpansionParameters) { + var param = new ParametersParameterComponent(); + param.setName("system-version"); + param.setValue(new UriType(parameter)); + newParameters.add(param); + } + } + if (canonicalVersionExpansionParameters != null && !canonicalVersionExpansionParameters.isEmpty()) { + for (String parameter : canonicalVersionExpansionParameters) { + var param = new ParametersParameterComponent(); + param.setName("canonical-version"); + param.setValue(new UriType(parameter)); + newParameters.add(param); + } + } + var existingExpansionParameters = getExpansionParameters(); + if (existingExpansionParameters.isPresent()) { + ((Parameters) existingExpansionParameters.get()).setParameter(newParameters); + } else { + var id = "#exp-params"; + var newExpansionParameters = new Parameters(); + newExpansionParameters.setParameter(newParameters); + newExpansionParameters.setId(id); + getLibrary().addContained(newExpansionParameters); + var expansionParamsExt = getLibrary().addExtension(); + expansionParamsExt.setUrl(Constants.CQF_EXPANSION_PARAMETERS); + expansionParamsExt.setValue(new Reference(id)); + } + } } diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r4/MeasureAdapter.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r4/MeasureAdapter.java index 05cbfddaa..452d7455b 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r4/MeasureAdapter.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r4/MeasureAdapter.java @@ -2,13 +2,17 @@ import java.util.ArrayList; import java.util.List; +import java.util.Optional; +import java.util.function.Consumer; import java.util.stream.Collectors; import org.hl7.fhir.instance.model.api.IDomainResource; import org.hl7.fhir.r4.model.CanonicalType; +import org.hl7.fhir.r4.model.Extension; import org.hl7.fhir.r4.model.Library; import org.hl7.fhir.r4.model.Measure; import org.hl7.fhir.r4.model.Reference; import org.hl7.fhir.r4.model.RelatedArtifact; +import org.hl7.fhir.r4.model.UriType; import org.opencds.cqf.fhir.utility.Constants; import org.opencds.cqf.fhir.utility.adapter.DependencyInfo; import org.opencds.cqf.fhir.utility.adapter.IDependencyInfo; @@ -45,6 +49,18 @@ public Measure copy() { private Library effectiveDataRequirements; private LibraryAdapter effectiveDataRequirementsAdapter; + private String getEdrReferenceString(Extension edrExtension) { + return edrExtension.getUrl().contains("cqfm") + ? ((Reference) edrExtension.getValue()).getReference() + : ((UriType) edrExtension.getValue()).getValue(); + } + + private Consumer getEdrReferenceConsumer(Extension edrExtension) { + return edrExtension.getUrl().contains("cqfm") + ? (reference) -> edrExtension.setValue(new Reference(reference)) + : (reference) -> edrExtension.setValue(new CanonicalType(reference)); + } + private void findEffectiveDataRequirements() { if (!checkedEffectiveDataRequirements) { var edrExtensions = this.getMeasure().getExtension().stream() @@ -53,10 +69,14 @@ private void findEffectiveDataRequirements() { .collect(Collectors.toList()); var edrExtension = edrExtensions.size() == 1 ? edrExtensions.get(0) : null; + // cqfm-effectiveDataRequirements is a Reference, crmi-effectiveDataRequirements is a canonical + var maybeEdrReference = Optional.ofNullable(edrExtension).map(e -> getEdrReferenceString(e)); if (edrExtension != null) { - var edrReference = ((CanonicalType) edrExtension.getValue()).getValue(); + var edrReference = maybeEdrReference.get(); for (var c : getMeasure().getContained()) { - if (c.hasId() && String.format("#%s", c.getId()).equals(edrReference) && c instanceof Library) { + if (c.hasId() + && (edrReference.equals(c.getId()) || edrReference.equals("#" + c.getId())) + && c instanceof Library) { effectiveDataRequirements = (Library) c; effectiveDataRequirementsAdapter = new LibraryAdapter(effectiveDataRequirements); } @@ -165,9 +185,9 @@ public List getDependencies() { .filter(e -> CANONICAL_EXTENSIONS.contains(e.getUrl())) .forEach(referenceExt -> references.add(new DependencyInfo( referenceSource, - ((CanonicalType) referenceExt.getValue()).getValue(), + getEdrReferenceString(referenceExt), referenceExt.getExtension(), - (reference) -> referenceExt.setValue(new CanonicalType(reference))))); + getEdrReferenceConsumer(referenceExt)))); // extension[cqfm-inputParameters][] // extension[cqfm-expansionParameters][] diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r5/LibraryAdapter.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r5/LibraryAdapter.java index e90371e6e..10ee3a0f2 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r5/LibraryAdapter.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r5/LibraryAdapter.java @@ -3,7 +3,9 @@ import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException; import java.util.ArrayList; import java.util.List; +import java.util.Optional; import java.util.stream.Collectors; +import org.hl7.fhir.instance.model.api.IBaseParameters; import org.hl7.fhir.instance.model.api.ICompositeType; import org.hl7.fhir.instance.model.api.IDomainResource; import org.hl7.fhir.r5.model.Attachment; @@ -11,8 +13,13 @@ import org.hl7.fhir.r5.model.Coding; import org.hl7.fhir.r5.model.DataRequirement; import org.hl7.fhir.r5.model.Library; +import org.hl7.fhir.r5.model.Parameters; +import org.hl7.fhir.r5.model.Parameters.ParametersParameterComponent; +import org.hl7.fhir.r5.model.Reference; import org.hl7.fhir.r5.model.RelatedArtifact; +import org.hl7.fhir.r5.model.UriType; import org.hl7.fhir.r5.model.UsageContext; +import org.opencds.cqf.fhir.utility.Constants; import org.opencds.cqf.fhir.utility.adapter.DependencyInfo; import org.opencds.cqf.fhir.utility.adapter.IDependencyInfo; @@ -141,4 +148,58 @@ public LibraryAdapter setDataRequirement(List data public List getUseContext() { return getLibrary().getUseContext(); } + + @Override + public Optional getExpansionParameters() { + return getLibrary().getExtension().stream() + .filter(ext -> ext.getUrl().equals(Constants.CQF_EXPANSION_PARAMETERS)) + .findAny() + .map(ext -> ((Reference) ext.getValue()).getReference()) + .map(ref -> { + if (getLibrary().hasContained()) { + return getLibrary().getContained().stream() + .filter(containedResource -> + containedResource.getId().equals(ref)) + .findFirst() + .map(r -> (IBaseParameters) r) + .orElse(null); + } + return null; + }); + } + + @Override + public void setExpansionParameters( + List systemVersionExpansionParameters, List canonicalVersionExpansionParameters) { + var newParameters = new ArrayList(); + if (systemVersionExpansionParameters != null && !systemVersionExpansionParameters.isEmpty()) { + for (String parameter : systemVersionExpansionParameters) { + var param = new ParametersParameterComponent(); + param.setName("system-version"); + param.setValue(new UriType(parameter)); + newParameters.add(param); + } + } + if (canonicalVersionExpansionParameters != null && !canonicalVersionExpansionParameters.isEmpty()) { + for (String parameter : canonicalVersionExpansionParameters) { + var param = new ParametersParameterComponent(); + param.setName("canonical-version"); + param.setValue(new UriType(parameter)); + newParameters.add(param); + } + } + var existingExpansionParameters = getExpansionParameters(); + if (existingExpansionParameters.isPresent()) { + ((Parameters) existingExpansionParameters.get()).setParameter(newParameters); + } else { + var id = "#exp-params"; + var newExpansionParameters = new Parameters(); + newExpansionParameters.setParameter(newParameters); + newExpansionParameters.setId(id); + getLibrary().addContained(newExpansionParameters); + var expansionParamsExt = getLibrary().addExtension(); + expansionParamsExt.setUrl(Constants.CQF_EXPANSION_PARAMETERS); + expansionParamsExt.setValue(new Reference(id)); + } + } } diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r5/MeasureAdapter.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r5/MeasureAdapter.java index eef30e04b..a06c5832b 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r5/MeasureAdapter.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/adapter/r5/MeasureAdapter.java @@ -2,13 +2,17 @@ import java.util.ArrayList; import java.util.List; +import java.util.Optional; +import java.util.function.Consumer; import java.util.stream.Collectors; import org.hl7.fhir.instance.model.api.IDomainResource; import org.hl7.fhir.r5.model.CanonicalType; +import org.hl7.fhir.r5.model.Extension; import org.hl7.fhir.r5.model.Library; import org.hl7.fhir.r5.model.Measure; import org.hl7.fhir.r5.model.Reference; import org.hl7.fhir.r5.model.RelatedArtifact; +import org.hl7.fhir.r5.model.UriType; import org.opencds.cqf.fhir.utility.Constants; import org.opencds.cqf.fhir.utility.adapter.DependencyInfo; import org.opencds.cqf.fhir.utility.adapter.IDependencyInfo; @@ -45,6 +49,18 @@ public Measure copy() { private Library effectiveDataRequirements; private LibraryAdapter effectiveDataRequirementsAdapter; + private String getEdrReferenceString(Extension edrExtension) { + return edrExtension.getUrl().contains("cqfm") + ? ((Reference) edrExtension.getValue()).getReference() + : ((UriType) edrExtension.getValue()).getValue(); + } + + private Consumer getEdrReferenceConsumer(Extension edrExtension) { + return edrExtension.getUrl().contains("cqfm") + ? (reference) -> edrExtension.setValue(new Reference(reference)) + : (reference) -> edrExtension.setValue(new CanonicalType(reference)); + } + private void findEffectiveDataRequirements() { if (!checkedEffectiveDataRequirements) { var edrExtensions = this.getMeasure().getExtension().stream() @@ -53,10 +69,14 @@ private void findEffectiveDataRequirements() { .collect(Collectors.toList()); var edrExtension = edrExtensions.size() == 1 ? edrExtensions.get(0) : null; + // cqfm-effectiveDataRequirements is a Reference, crmi-effectiveDataRequirements is a canonical + var maybeEdrReference = Optional.ofNullable(edrExtension).map(e -> getEdrReferenceString(e)); if (edrExtension != null) { - var edrReference = ((CanonicalType) edrExtension.getValue()).getValue(); + var edrReference = maybeEdrReference.get(); for (var c : getMeasure().getContained()) { - if (c.hasId() && String.format("#%s", c.getId()).equals(edrReference) && c instanceof Library) { + if (c.hasId() + && (edrReference.equals(c.getId()) || edrReference.equals("#" + c.getId())) + && c instanceof Library) { effectiveDataRequirements = (Library) c; effectiveDataRequirementsAdapter = new LibraryAdapter(effectiveDataRequirements); } @@ -165,9 +185,9 @@ public List getDependencies() { .filter(e -> CANONICAL_EXTENSIONS.contains(e.getUrl())) .forEach(referenceExt -> references.add(new DependencyInfo( referenceSource, - ((CanonicalType) referenceExt.getValue()).getValue(), + getEdrReferenceString(referenceExt), referenceExt.getExtension(), - (reference) -> referenceExt.setValue(new CanonicalType(reference))))); + getEdrReferenceConsumer(referenceExt)))); // extension[cqfm-inputParameters][] // extension[cqfm-expansionParameters][] diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/matcher/ResourceMatcher.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/matcher/ResourceMatcher.java index f84b7e8de..3252ea1a9 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/matcher/ResourceMatcher.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/matcher/ResourceMatcher.java @@ -16,6 +16,7 @@ import java.util.Map; import org.apache.commons.lang3.NotImplementedException; import org.hl7.fhir.instance.model.api.IBase; +import org.hl7.fhir.instance.model.api.IBaseEnumeration; import org.hl7.fhir.instance.model.api.IBaseReference; import org.hl7.fhir.instance.model.api.IBaseResource; import org.hl7.fhir.instance.model.api.ICompositeType; @@ -204,6 +205,10 @@ default boolean isMatchToken(TokenParam param, IBase pathResult) { return param.getValue().equals(id.getIdPart()); } + if (pathResult instanceof IBaseEnumeration) { + return param.getValue().equals(((IBaseEnumeration) pathResult).getValueAsString()); + } + if (pathResult instanceof IPrimitiveType) { return param.getValue().equals(((IPrimitiveType) pathResult).getValue()); } diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/repository/InMemoryFhirRepository.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/repository/InMemoryFhirRepository.java index 0a227118c..4f75d24ae 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/repository/InMemoryFhirRepository.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/repository/InMemoryFhirRepository.java @@ -8,6 +8,7 @@ import ca.uhn.fhir.rest.param.TokenParam; import ca.uhn.fhir.rest.server.exceptions.NotImplementedOperationException; import ca.uhn.fhir.rest.server.exceptions.ResourceNotFoundException; +import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException; import ca.uhn.fhir.util.BundleBuilder; import ca.uhn.fhir.util.BundleUtil; import java.util.ArrayList; @@ -175,7 +176,16 @@ public B search( } if (include) { - builder.addCollectionEntry(resource); + if (resource instanceof org.hl7.fhir.dstu3.model.Resource) { + builder.addCollectionEntry(((org.hl7.fhir.dstu3.model.Resource) resource).copy()); + } else if (resource instanceof org.hl7.fhir.r4.model.Resource) { + builder.addCollectionEntry(((org.hl7.fhir.r4.model.Resource) resource).copy()); + } else if (resource instanceof org.hl7.fhir.r5.model.Resource) { + builder.addCollectionEntry(((org.hl7.fhir.r5.model.Resource) resource).copy()); + } else { + throw new UnprocessableEntityException("Unsupported fhir version:" + + resource.getStructureFhirVersionEnum().getFhirVersionString()); + } } } diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/search/Searches.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/search/Searches.java index 6d6bee449..277beae4f 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/search/Searches.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/search/Searches.java @@ -62,6 +62,10 @@ public static Map> byName(String name) { return builder().withStringParam("name", name).build(); } + public static Map> byStatus(String status) { + return builder().withTokenParam("status", status).build(); + } + public static Map> byNameAndVersion(String name, String version) { if (version == null || version.isEmpty()) { return builder().withStringParam("name", name).build(); diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/visitor/ReleaseVisitor.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/visitor/ReleaseVisitor.java index a5b53c6b2..1d788c519 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/visitor/ReleaseVisitor.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/visitor/ReleaseVisitor.java @@ -1,7 +1,5 @@ package org.opencds.cqf.fhir.utility.visitor; -import static java.util.Comparator.comparing; - import ca.uhn.fhir.context.FhirVersionEnum; import ca.uhn.fhir.rest.server.exceptions.InternalErrorException; import ca.uhn.fhir.rest.server.exceptions.NotImplementedOperationException; @@ -10,7 +8,9 @@ import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException; import java.util.ArrayList; import java.util.Date; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.regex.Pattern; import java.util.stream.Collectors; @@ -30,6 +30,8 @@ import org.opencds.cqf.fhir.utility.adapter.AdapterFactory; import org.opencds.cqf.fhir.utility.adapter.IDependencyInfo; import org.opencds.cqf.fhir.utility.adapter.KnowledgeArtifactAdapter; +import org.opencds.cqf.fhir.utility.adapter.LibraryAdapter; +import org.opencds.cqf.fhir.utility.search.Searches; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -39,7 +41,6 @@ public class ReleaseVisitor implements KnowledgeArtifactVisitor { @Override public IBase visit( KnowledgeArtifactAdapter rootAdapter, Repository repository, IBaseParameters operationParameters) { - // boolean latestFromTxServer = operationParameters.getParameterBool("latestFromTxServer"); Optional latestFromTxServer = VisitorHelper.getParameter( "latestFromTxServer", operationParameters, IPrimitiveType.class) .map(t -> (Boolean) t.getValue()); @@ -47,23 +48,22 @@ public IBase visit( if (latestFromTxServer.isPresent()) { throw new NotImplementedOperationException("Support for 'latestFromTxServer' is not yet implemented."); } - String version = VisitorHelper.getParameter("version", operationParameters, IPrimitiveType.class) + var version = VisitorHelper.getParameter("version", operationParameters, IPrimitiveType.class) .map(t -> (String) t.getValue()) .orElseThrow(() -> new UnprocessableEntityException("Version must be present")); - String releaseLabel = VisitorHelper.getParameter("releaseLabel", operationParameters, IPrimitiveType.class) + var releaseLabel = VisitorHelper.getParameter("releaseLabel", operationParameters, IPrimitiveType.class) .map(t -> (String) t.getValue()) .orElse(""); - Optional versionBehavior = VisitorHelper.getParameter( - "versionBehavior", operationParameters, IPrimitiveType.class) + var versionBehavior = VisitorHelper.getParameter("versionBehavior", operationParameters, IPrimitiveType.class) .map(t -> (String) t.getValue()); - Optional requireNonExperimental = VisitorHelper.getParameter( + var requireNonExperimental = VisitorHelper.getParameter( "requireNonExperimental", operationParameters, IPrimitiveType.class) .map(t -> (String) t.getValue()); checkReleaseVersion(version, versionBehavior); + checkReleasePreconditions(rootAdapter, rootAdapter.getApprovalDate()); var rootLibrary = rootAdapter.get(); + updateReleaseLabel(rootLibrary, releaseLabel); var fhirVersion = rootLibrary.getStructureFhirVersionEnum(); - var currentApprovalDate = rootAdapter.getApprovalDate(); - checkReleasePreconditions(rootAdapter, currentApprovalDate); // Determine which version should be used. var existingVersion = @@ -82,8 +82,8 @@ public IBase visit( rootEffectivePeriod, latestFromTxServer.orElse(false), requireNonExperimental, - repository); - updateReleaseLabel(rootLibrary, releaseLabel); + repository, + new Date()); var rootArtifactOriginalDependencies = new ArrayList(rootAdapter.getDependencies()); // Get list of extensions which need to be preserved var originalDependenciesWithExtensions = rootArtifactOriginalDependencies.stream() @@ -92,71 +92,34 @@ public IBase visit( // once iteration is complete, delete all depends-on RAs in the root artifact rootAdapter.getRelatedArtifact().removeIf(ra -> KnowledgeArtifactAdapter.getRelatedArtifactType(ra) .equalsIgnoreCase("depends-on")); + var expansionParameters = rootAdapter.getExpansionParameters(); + var systemVersionParams = expansionParameters + .map(p -> VisitorHelper.getListParameter("system-version", p, IPrimitiveType.class) + .orElse(null)) + .map(versions -> + versions.stream().map(v -> (String) v.getValue()).collect(Collectors.toList())) + .orElse(new ArrayList()); + var canonicalVersionParams = expansionParameters + .map(p -> VisitorHelper.getListParameter("canonical-version", p, IPrimitiveType.class) + .orElse(null)) + .map(versions -> + versions.stream().map(v -> (String) v.getValue()).collect(Collectors.toList())) + .orElse(new ArrayList()); - var transactionBundle = BundleHelper.newBundle(fhirVersion, null, "transaction"); - for (var artifact : releasedResources) { - var entry = PackageHelper.createEntry(artifact, true); - BundleHelper.addEntry(transactionBundle, entry); - var artifactAdapter = AdapterFactory.forFhirVersion(fhirVersion).createKnowledgeArtifactAdapter(artifact); - var components = artifactAdapter.getComponents(); - // add all root artifact components and child artifact components recursively as root artifact dependencies - for (var component : components) { - IDomainResource resource; - var relatedArtifactReference = KnowledgeArtifactAdapter.getRelatedArtifactReference(component); - // if the relatedArtifact is Owned, need to update the reference to the new Version - if (KnowledgeArtifactAdapter.checkIfRelatedArtifactIsOwned(component)) { - resource = checkIfReferenceInList(relatedArtifactReference, releasedResources) - // should never happen since we check all references as part of `internalRelease` - .orElseThrow(() -> - new InternalErrorException("Owned resource reference not found during release")); - var adapter = AdapterFactory.forFhirVersion(resource.getStructureFhirVersionEnum()) - .createKnowledgeArtifactAdapter(resource); - var reference = String.format("%s|%s", adapter.getUrl(), adapter.getVersion()); - KnowledgeArtifactAdapter.setRelatedArtifactReference(component, reference, null); - } else if (Canonicals.getVersion(relatedArtifactReference) == null - || Canonicals.getVersion(relatedArtifactReference).isEmpty()) { - // if the not Owned component doesn't have a version, try to find the latest version - String updatedReference = tryUpdateReferenceToLatestActiveVersion( - relatedArtifactReference, repository, artifactAdapter.getUrl()); - KnowledgeArtifactAdapter.setRelatedArtifactReference(component, updatedReference, null); - } - var componentToDependency = KnowledgeArtifactAdapter.newRelatedArtifact( - fhirVersion, - "depends-on", - KnowledgeArtifactAdapter.getRelatedArtifactReference(component), - null); - var relatedArtifacts = rootAdapter.getRelatedArtifact(); - relatedArtifacts.add(componentToDependency); - rootAdapter.setRelatedArtifact(relatedArtifacts); - } - - var dependencies = artifactAdapter.getDependencies(); - for (var dependency : dependencies) { - // if the dependency gets updated as part of $release then update the reference as well - var maybeReference = checkIfReferenceInList(dependency, releasedResources); - if (maybeReference.isPresent()) { - var adapter = AdapterFactory.forFhirVersion(fhirVersion) - .createKnowledgeArtifactAdapter(maybeReference.get()); - String updatedReference = adapter.hasVersion() - ? String.format("%s|%s", adapter.getUrl(), adapter.getVersion()) - : adapter.getUrl(); - dependency.setReference(updatedReference); - } else if (StringUtils.isBlank(Canonicals.getVersion(dependency.getReference()))) { - // TODO: update when we support expansionParameters and requireVersionedDependencies - String updatedReference = tryUpdateReferenceToLatestActiveVersion( - dependency.getReference(), repository, artifactAdapter.getUrl()); - dependency.setReference(updatedReference); - } - // only add the dependency to the manifest if it is from a leaf artifact - if (!artifactAdapter.getUrl().equals(rootAdapter.getUrl())) { - var newDep = KnowledgeArtifactAdapter.newRelatedArtifact( - fhirVersion, "depends-on", dependency.getReference(), null); - var relatedArtifacts = rootAdapter.getRelatedArtifact(); - relatedArtifacts.add(newDep); - rootAdapter.setRelatedArtifact(relatedArtifacts); - } - } + // Report all dependencies, resolving unversioned dependencies to the latest known version, recursively + gatherDependencies( + rootAdapter, + rootAdapter, + releasedResources, + fhirVersion, + repository, + new HashMap(), + systemVersionParams, + canonicalVersionParams); + if (rootAdapter.get().fhirType().equals("Library")) { + ((LibraryAdapter) rootAdapter).setExpansionParameters(systemVersionParams, canonicalVersionParams); } + // removed duplicates and add var relatedArtifacts = rootAdapter.getRelatedArtifact(); var distinctResolvedRelatedArtifacts = new ArrayList<>(relatedArtifacts); @@ -188,77 +151,235 @@ public IBase visit( }); } } + + // Add all updated resources to a transaction bundle for the result + var transactionBundle = BundleHelper.newBundle(fhirVersion, null, "transaction"); + for (var artifact : releasedResources) { + var entry = PackageHelper.createEntry(artifact, true); + BundleHelper.addEntry(transactionBundle, entry); + } + // update ArtifactComments referencing the old Canonical Reference findArtifactCommentsToUpdate(rootLibrary, releaseVersion, repository).forEach(entry -> { BundleHelper.addEntry(transactionBundle, entry); }); rootAdapter.setRelatedArtifact(distinctResolvedRelatedArtifacts); + // return transactionBundle; return repository.transaction(transactionBundle); } + private static void updateMetadata( + KnowledgeArtifactAdapter artifactAdapter, + String version, + ICompositeType rootEffectivePeriod, + Date current) { + artifactAdapter.setDate(current == null ? new Date() : current); + artifactAdapter.setStatus("active"); + artifactAdapter.setVersion(version); + propagateEffectivePeriod(rootEffectivePeriod, artifactAdapter); + } + private List internalRelease( KnowledgeArtifactAdapter artifactAdapter, String version, ICompositeType rootEffectivePeriod, boolean latestFromTxServer, Optional experimentalBehavior, - Repository repository) + Repository repository, + Date current) throws NotImplementedOperationException, ResourceNotFoundException { var resourcesToUpdate = new ArrayList(); + // Step 1: Update the Date, version and propagate effectivePeriod if it doesn't exist + updateMetadata(artifactAdapter, version, rootEffectivePeriod, current); + // Step 2: add the resource to the list of released resources + resourcesToUpdate.add(artifactAdapter.get()); + // Step 3 : Go through all the components, update them and recursively release them if Owned + for (var component : artifactAdapter.getComponents()) { + final var preReleaseReference = KnowledgeArtifactAdapter.getRelatedArtifactReference(component); + if (!StringUtils.isBlank(preReleaseReference)) { + // For composed-of references, if a version is NOT specified in the reference + // then the latest version of the referenced artifact should be used. - // Step 1: Update the Date and the version - // Need to update the Date element because we're changing the status - artifactAdapter.setDate(new Date()); - artifactAdapter.setStatus("active"); - artifactAdapter.setVersion(version); - // Step 2: propagate effectivePeriod if it doesn't exist - propagateEffectivePeriod(rootEffectivePeriod, artifactAdapter); + // If a version IS specified then `tryGetLatestVersion` + // will return that version. + var alreadyUpdated = checkIfReferenceInList(preReleaseReference, resourcesToUpdate); + if (KnowledgeArtifactAdapter.checkIfRelatedArtifactIsOwned(component) && !alreadyUpdated.isPresent()) { + // get the latest version regardless of status because it's owned and we're releasing it + var latest = tryGetLatestVersion(preReleaseReference, repository); + if (latest.isPresent()) { + checkNonExperimental(latest.get().get(), experimentalBehavior, repository); + // release components recursively + resourcesToUpdate.addAll(internalRelease( + latest.get(), + version, + rootEffectivePeriod, + latestFromTxServer, + experimentalBehavior, + repository, + current)); + } else { + // if missing throw because it's an owned resource + throw new ResourceNotFoundException(String.format( + "Resource with URL '%s' is Owned by this repository and referenced by resource '%s', but no active version was found on the server.", + preReleaseReference, artifactAdapter.getUrl())); + } + } else if (!alreadyUpdated.isPresent()) { + // if it's a not-owned component just try to get the latest active version + tryGetLatestVersionWithStatus(preReleaseReference, repository, "active") + .ifPresent(latestActive -> + // check if it's experimental + checkNonExperimental(latestActive.get(), experimentalBehavior, repository)); + } + } + } + return resourcesToUpdate; + } - resourcesToUpdate.add(artifactAdapter.get()); - var ownedRelatedArtifacts = artifactAdapter.getOwnedRelatedArtifacts(); - // Step 3 : Get all the OWNED relatedArtifacts - for (var ownedRelatedArtifact : ownedRelatedArtifacts) { - var ownedRelatedArtifactReference = - KnowledgeArtifactAdapter.getRelatedArtifactReference(ownedRelatedArtifact); - if (!StringUtils.isBlank(ownedRelatedArtifactReference)) { - IDomainResource referencedResource; - // IPrimitiveType ownedResourceReference = ownedRelatedArtifact.getResourceElement(); - Boolean alreadyUpdated = resourcesToUpdate.stream() - .map(resource -> AdapterFactory.forFhirVersion(resource.getStructureFhirVersionEnum()) - .createKnowledgeArtifactAdapter(resource)) - .filter(r -> r.getUrl().equals(Canonicals.getUrl(ownedRelatedArtifactReference))) - .findAny() - .isPresent(); - if (!alreadyUpdated) { - // For composition references, if a version is not specified in the reference then the latest - // version - // of the referenced artifact should be used. If a version is specified then - // `searchRepositoryByCanonicalWithPaging` will - // return that version. - referencedResource = KnowledgeArtifactAdapter.findLatestVersion( - SearchHelper.searchRepositoryByCanonicalWithPaging( - repository, ownedRelatedArtifactReference)) - .orElseThrow(() -> new ResourceNotFoundException(String.format( - "Resource with URL '%s' is Owned by this repository and referenced by resource '%s', but was not found on the server.", - ownedRelatedArtifactReference, artifactAdapter.getUrl()))); - KnowledgeArtifactAdapter searchResultAdapter = AdapterFactory.forFhirVersion( - referencedResource.getStructureFhirVersionEnum()) - .createKnowledgeArtifactAdapter(referencedResource); + private void gatherDependencies( + KnowledgeArtifactAdapter rootAdapter, + KnowledgeArtifactAdapter artifactAdapter, + List releasedResources, + FhirVersionEnum fhirVersion, + Repository repository, + Map alreadyUpdatedDependencies, + List systemVersionExpansionParameters, + List canonicalVersionExpansionParameters) { - checkNonExperimental(referencedResource, experimentalBehavior, repository); - resourcesToUpdate.addAll(internalRelease( - searchResultAdapter, - version, - rootEffectivePeriod, - latestFromTxServer, - experimentalBehavior, - repository)); + // Step 1: Check components, add them to the cache and convert to dependencies + for (var component : artifactAdapter.getComponents()) { + // all components are already updated to latest as part of release + var preReleaseReference = KnowledgeArtifactAdapter.getRelatedArtifactReference(component); + var updatedReference = preReleaseReference; + Optional res = Optional.empty(); + if (KnowledgeArtifactAdapter.checkIfRelatedArtifactIsOwned(component)) { + res = checkIfReferenceInList(preReleaseReference, releasedResources); + if (!res.isPresent()) { + // should never happen since we check all references as part of `internalRelease` + throw new InternalErrorException( + "Owned resource reference not found during release: " + preReleaseReference); + } + } else { + res = tryGetLatestVersion(preReleaseReference, repository); + } + if (res.isPresent()) { + // add to cache if resolvable + if (!alreadyUpdatedDependencies.containsKey(Canonicals.getUrl(preReleaseReference))) { + alreadyUpdatedDependencies.put( + Canonicals.getUrl(preReleaseReference), res.get().get()); } + // update the reference to latest + updatedReference = res.get().hasVersion() + ? String.format("%s|%s", res.get().getUrl(), res.get().getVersion()) + : res.get().getUrl(); + KnowledgeArtifactAdapter.setRelatedArtifactReference( + component, updatedReference, res.get().getDescriptor()); } + var componentToDependency = KnowledgeArtifactAdapter.newRelatedArtifact( + fhirVersion, + "depends-on", + updatedReference, + res.map(a -> a.getDescriptor()).orElse(null)); + var updatedRelatedArtifacts = artifactAdapter.getRelatedArtifact(); + updatedRelatedArtifacts.add(componentToDependency); + artifactAdapter.setRelatedArtifact(updatedRelatedArtifacts); } + var dependencies = artifactAdapter.getDependencies(); + // Step 2: update dependencies recursively + for (var dependency : dependencies) { + KnowledgeArtifactAdapter dependencyAdapter = null; + if (alreadyUpdatedDependencies.containsKey(Canonicals.getUrl(dependency.getReference()))) { + dependencyAdapter = AdapterFactory.forFhirVersion(fhirVersion) + .createKnowledgeArtifactAdapter( + alreadyUpdatedDependencies.get(Canonicals.getUrl(dependency.getReference()))); + String versionedReference = addVersionToReference(dependency.getReference(), dependencyAdapter); + dependency.setReference(versionedReference); - return resourcesToUpdate; + // the dependency is already updated we just need to recurse into it + gatherDependencies( + rootAdapter, + dependencyAdapter, + releasedResources, + fhirVersion, + repository, + alreadyUpdatedDependencies, + systemVersionExpansionParameters, + canonicalVersionExpansionParameters); + } else { + // try to get versions from expansion parameters if they are available + var resourceType = Canonicals.getResourceType(dependency.getReference()) == null + ? null + : SearchHelper.getResourceType(repository, dependency); + if (StringUtils.isBlank(Canonicals.getVersion(dependency.getReference()))) { + // TODO: update when we support requireVersionedDependencies + Optional expansionParametersVersion = Optional.empty(); + // assume if we can't figure out the resource type it's a CodeSystem + if (resourceType == null || resourceType.getSimpleName().equals("CodeSystem")) { + expansionParametersVersion = systemVersionExpansionParameters.stream() + .filter(canonical -> !StringUtils.isBlank(Canonicals.getUrl(canonical))) + .filter(canonical -> + Canonicals.getUrl(canonical).equals(dependency.getReference())) + .findAny(); + } else if (resourceType.getSimpleName().equals("ValueSet")) { + expansionParametersVersion = canonicalVersionExpansionParameters.stream() + .filter(canonical -> + Canonicals.getUrl(canonical).equals(dependency.getReference())) + .findAny(); + } + expansionParametersVersion + .map(canonical -> Canonicals.getVersion(canonical)) + .ifPresent(version -> dependency.setReference(dependency.getReference() + "|" + version)); + } + Optional maybeAdapter = Optional.empty(); + // if not available in expansion parameters then try to find the latest version and update the + // dependency + if (StringUtils.isBlank(Canonicals.getVersion(dependency.getReference()))) { + maybeAdapter = tryGetLatestVersionWithStatus(dependency.getReference(), repository, "active") + .map(adapter -> { + String versionedReference = addVersionToReference(dependency.getReference(), adapter); + dependency.setReference(versionedReference); + // if we don't know the version even at this point then they are missing from the + // expansion parameters, hence update the expansion parameters + if (resourceType == null + || resourceType.getSimpleName().equals("CodeSystem")) { + systemVersionExpansionParameters.add(versionedReference); + } else if (resourceType.getSimpleName().equals("ValueSet")) { + canonicalVersionExpansionParameters.add(versionedReference); + } + alreadyUpdatedDependencies.put( + Canonicals.getUrl(dependency.getReference()), adapter.get()); + return adapter; + }); + } else { + // This is a versioned reference, just get the dependency + maybeAdapter = Optional.ofNullable(getArtifactByCanonical(dependency.getReference(), repository)); + } + // if the dependency is resolvable then recurse into it + if (maybeAdapter.isPresent()) { + dependencyAdapter = maybeAdapter.get(); + gatherDependencies( + rootAdapter, + dependencyAdapter, + releasedResources, + fhirVersion, + repository, + alreadyUpdatedDependencies, + systemVersionExpansionParameters, + canonicalVersionExpansionParameters); + } + } + // only add the dependency to the manifest if it is from a leaf artifact + if (!artifactAdapter.getUrl().equals(rootAdapter.getUrl())) { + var newDep = KnowledgeArtifactAdapter.newRelatedArtifact( + fhirVersion, + "depends-on", + dependency.getReference(), + dependencyAdapter != null ? dependencyAdapter.getDescriptor() : null); + var updatedRelatedArtifacts = rootAdapter.getRelatedArtifact(); + updatedRelatedArtifacts.add(newDep); + rootAdapter.setRelatedArtifact(updatedRelatedArtifacts); + } + } } private void checkNonExperimental( @@ -293,7 +414,7 @@ private void checkNonExperimental( } } - private void propagateEffectivePeriod( + private static void propagateEffectivePeriod( ICompositeType rootEffectivePeriod, KnowledgeArtifactAdapter artifactAdapter) { if (rootEffectivePeriod instanceof org.hl7.fhir.dstu3.model.Period) { org.opencds.cqf.fhir.utility.visitor.dstu3.ReleaseVisitor.propagateEffectivePeriod( @@ -310,30 +431,49 @@ private void propagateEffectivePeriod( } } - private String tryUpdateReferenceToLatestActiveVersion( - String inputReference, Repository repository, String sourceArtifactUrl) throws ResourceNotFoundException { + private KnowledgeArtifactAdapter getArtifactByCanonical(String inputReference, Repository repository) { List matchingResources = VisitorHelper.getMetadataResourcesFromBundle( SearchHelper.searchRepositoryByCanonicalWithPaging(repository, inputReference)) .stream() .map(r -> AdapterFactory.forFhirVersion(r.getStructureFhirVersionEnum()) - .createKnowledgeArtifactAdapter((IDomainResource) r)) - .filter(a -> a.getStatus().equals("active")) + .createKnowledgeArtifactAdapter(r)) .collect(Collectors.toList()); - if (matchingResources.isEmpty()) { - return inputReference; + return null; + } else if (matchingResources.size() == 1) { + return matchingResources.get(0); } else { - // TODO: Log which version was selected - matchingResources.sort( - comparing(r -> ((KnowledgeArtifactAdapter) r).getVersion()).reversed()); - var latestActiveVersion = matchingResources.get(0); - String latestActiveReference = latestActiveVersion.hasVersion() - ? String.format("%s|%s", latestActiveVersion.getUrl(), latestActiveVersion.getVersion()) - : latestActiveVersion.getUrl(); - return latestActiveReference; + // TODO: Log that multiple resources matched by url and version... + return matchingResources.get(0); } } + private Optional tryGetLatestVersionWithStatus( + String inputReference, Repository repository, String status) { + return KnowledgeArtifactAdapter.findLatestVersion(SearchHelper.searchRepositoryByCanonicalWithPagingWithParams( + repository, inputReference, Searches.byStatus(status))) + .map(res -> AdapterFactory.forFhirVersion(res.getStructureFhirVersionEnum()) + .createKnowledgeArtifactAdapter(res)); + } + + private Optional tryGetLatestVersion(String inputReference, Repository repository) { + return KnowledgeArtifactAdapter.findLatestVersion( + SearchHelper.searchRepositoryByCanonicalWithPaging(repository, inputReference)) + .map(res -> AdapterFactory.forFhirVersion(res.getStructureFhirVersionEnum()) + .createKnowledgeArtifactAdapter(res)); + } + + private String addVersionToReference(String inputReference, KnowledgeArtifactAdapter adapter) { + if (adapter != null) { + String versionedReference = adapter.hasVersion() + ? String.format("%s|%s", adapter.getUrl(), adapter.getVersion()) + : adapter.getUrl(); + return versionedReference; + } + + return inputReference; + } + private Optional getReleaseVersion( String version, Optional versionBehavior, String existingVersion, FhirVersionEnum fhirVersion) throws UnprocessableEntityException { @@ -371,37 +511,19 @@ private void updateReleaseLabel(IBaseResource artifact, String releaseLabel) thr } } - private Optional checkIfReferenceInList( + private Optional checkIfReferenceInList( String referenceToCheck, List resourceList) { - Optional updatedReference = Optional.ofNullable(null); for (var resource : resourceList) { String referenceURL = Canonicals.getUrl(referenceToCheck); String currentResourceURL = AdapterFactory.forFhirVersion(resource.getStructureFhirVersionEnum()) .createKnowledgeArtifactAdapter(resource) .getUrl(); if (referenceURL.equals(currentResourceURL)) { - return Optional.of(resource); - } - } - return updatedReference; - } - - private Optional checkIfReferenceInList( - IDependencyInfo artifactToUpdate, List resourceList) { - Optional updatedReference = Optional.ofNullable(null); - for (var resource : resourceList) { - if (artifactToUpdate == null) { - throw new UnprocessableEntityException("Could not resolve missing RelatedArtifact reference"); - } - String referenceURL = Canonicals.getUrl(artifactToUpdate.getReference()); - String currentResourceURL = AdapterFactory.forFhirVersion(resource.getStructureFhirVersionEnum()) - .createKnowledgeArtifactAdapter(resource) - .getUrl(); - if (referenceURL.equals(currentResourceURL)) { - return Optional.of(resource); + return Optional.of(resource).map(res -> AdapterFactory.forFhirVersion(res.getStructureFhirVersionEnum()) + .createKnowledgeArtifactAdapter(res)); } } - return updatedReference; + return Optional.empty(); } private void checkReleasePreconditions(KnowledgeArtifactAdapter artifact, Date approvalDate) diff --git a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/visitor/VisitorHelper.java b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/visitor/VisitorHelper.java index cc54beddc..3eaf7cd7f 100644 --- a/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/visitor/VisitorHelper.java +++ b/cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/visitor/VisitorHelper.java @@ -11,6 +11,7 @@ import org.hl7.fhir.instance.model.api.IBaseParameters; import org.hl7.fhir.instance.model.api.IBaseResource; import org.hl7.fhir.instance.model.api.ICompositeType; +import org.hl7.fhir.instance.model.api.IDomainResource; import org.hl7.fhir.instance.model.api.IPrimitiveType; import org.opencds.cqf.fhir.utility.BundleHelper; import org.opencds.cqf.fhir.utility.Canonicals; @@ -51,8 +52,8 @@ public static Optional> getListParameter( .map(vals -> vals.stream().map(val -> (T) val).collect(Collectors.toList())); } - public static List getMetadataResourcesFromBundle(IBaseBundle bundle) { - List resourceList = new ArrayList<>(); + public static List getMetadataResourcesFromBundle(IBaseBundle bundle) { + List resourceList = new ArrayList<>(); var version = bundle.getStructureFhirVersionEnum(); if (!BundleHelper.getEntryFirstRep(bundle).isEmpty()) { BundleHelper.getEntry(bundle).stream() @@ -62,17 +63,17 @@ public static List getMetadataResourcesFromBundle(IBaseBundle bun switch (version) { case DSTU3: if (r instanceof org.hl7.fhir.dstu3.model.MetadataResource) { - resourceList.add(r); + resourceList.add((IDomainResource) r); } break; case R4: if (r instanceof org.hl7.fhir.r4.model.MetadataResource) { - resourceList.add(r); + resourceList.add((IDomainResource) r); } break; case R5: if (r instanceof org.hl7.fhir.r5.model.MetadataResource) { - resourceList.add(r); + resourceList.add((IDomainResource) r); } break; default: diff --git a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/SearchHelperTest.java b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/SearchHelperTest.java new file mode 100644 index 000000000..4bb5df813 --- /dev/null +++ b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/SearchHelperTest.java @@ -0,0 +1,116 @@ +package org.opencds.cqf.fhir.utility; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.isNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import ca.uhn.fhir.context.FhirContext; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.opencds.cqf.fhir.api.Repository; + +public class SearchHelperTest { + private Repository R4mockRepository; + private Repository R5mockRepository; + private Repository DSTU3mockRepository; + + @BeforeEach + void resetRepository() { + R4mockRepository = mockRepositoryWithValueSetR4(new org.hl7.fhir.r4.model.ValueSet()); + R5mockRepository = mockRepositoryWithValueSetR5(new org.hl7.fhir.r5.model.ValueSet()); + DSTU3mockRepository = mockRepositoryWithValueSetDstu3(new org.hl7.fhir.dstu3.model.ValueSet()); + } + + @Test + void getResourceTypeTest() { + var validResourceTypeR4Canonical = new org.hl7.fhir.r4.model.CanonicalType("www.test.com/fhir/ValueSet/123"); + assertEquals( + org.hl7.fhir.r4.model.ValueSet.class, + SearchHelper.getResourceType(R4mockRepository, validResourceTypeR4Canonical)); + var invalidResourceTypeR4Canonical = + new org.hl7.fhir.r4.model.CanonicalType("www.test.com/fhir/invalid-resource-type/123"); + assertEquals( + org.hl7.fhir.r4.model.CodeSystem.class, + SearchHelper.getResourceType(R4mockRepository, invalidResourceTypeR4Canonical)); + var cqfResourceType = "Condition"; + var invalidResourceTypeR4CanonicalWithCqfResourceTypeExtension = + new org.hl7.fhir.r4.model.CanonicalType("www.test.com/fhir/invalid-resource-type/123"); + invalidResourceTypeR4CanonicalWithCqfResourceTypeExtension + .addExtension() + .setUrl(Constants.CQF_RESOURCETYPE) + .setValue(new org.hl7.fhir.r4.model.CodeType(cqfResourceType)); + assertEquals( + org.hl7.fhir.r4.model.Condition.class, + SearchHelper.getResourceType( + R4mockRepository, invalidResourceTypeR4CanonicalWithCqfResourceTypeExtension)); + + var validResourceTypeR5Canonical = new org.hl7.fhir.r5.model.CanonicalType("www.test.com/fhir/ValueSet/123"); + assertEquals( + org.hl7.fhir.r5.model.ValueSet.class, + SearchHelper.getResourceType(R5mockRepository, validResourceTypeR5Canonical)); + var invalidResourceTypeR5Canonical = + new org.hl7.fhir.r5.model.CanonicalType("www.test.com/fhir/invalid-resource-type/123"); + assertEquals( + org.hl7.fhir.r5.model.CodeSystem.class, + SearchHelper.getResourceType(R5mockRepository, invalidResourceTypeR5Canonical)); + var invalidResourceTypeR5CanonicalWithCqfResourceTypeExtension = + new org.hl7.fhir.r5.model.CanonicalType("www.test.com/fhir/invalid-resource-type/123"); + invalidResourceTypeR5CanonicalWithCqfResourceTypeExtension + .addExtension() + .setUrl(Constants.CQF_RESOURCETYPE) + .setValue(new org.hl7.fhir.r5.model.CodeType(cqfResourceType)); + assertEquals( + org.hl7.fhir.r5.model.Condition.class, + SearchHelper.getResourceType( + R5mockRepository, invalidResourceTypeR5CanonicalWithCqfResourceTypeExtension)); + + var validResourceTypeDstu3Canonical = new org.hl7.fhir.dstu3.model.UriType("www.test.com/fhir/ValueSet/123"); + assertEquals( + org.hl7.fhir.dstu3.model.ValueSet.class, + SearchHelper.getResourceType(DSTU3mockRepository, validResourceTypeDstu3Canonical)); + var invalidResourceTypeDstu3Canonical = + new org.hl7.fhir.dstu3.model.UriType("www.test.com/fhir/invalid-resource-type/123"); + assertEquals( + org.hl7.fhir.dstu3.model.CodeSystem.class, + SearchHelper.getResourceType(DSTU3mockRepository, invalidResourceTypeDstu3Canonical)); + var invalidResourceTypeDstu3CanonicalWithCqfResourceTypeExtension = + new org.hl7.fhir.dstu3.model.UriType("www.test.com/fhir/invalid-resource-type/123"); + invalidResourceTypeDstu3CanonicalWithCqfResourceTypeExtension + .addExtension() + .setUrl(Constants.CQF_RESOURCETYPE) + .setValue(new org.hl7.fhir.dstu3.model.CodeType(cqfResourceType)); + assertEquals( + org.hl7.fhir.dstu3.model.Condition.class, + SearchHelper.getResourceType( + DSTU3mockRepository, invalidResourceTypeDstu3CanonicalWithCqfResourceTypeExtension)); + } + + Repository mockRepositoryWithValueSetR4(org.hl7.fhir.r4.model.ValueSet valueSet) { + var mockRepository = mock(Repository.class); + when(mockRepository.fhirContext()).thenReturn(FhirContext.forR4Cached()); + org.hl7.fhir.r4.model.Bundle bundle = new org.hl7.fhir.r4.model.Bundle(); + bundle.addEntry().setFullUrl(valueSet.getUrl()).setResource(valueSet); + when(mockRepository.search(any(), any(), any(), isNull())).thenReturn(bundle); + return mockRepository; + } + + Repository mockRepositoryWithValueSetR5(org.hl7.fhir.r5.model.ValueSet valueSet) { + var mockRepository = mock(Repository.class); + when(mockRepository.fhirContext()).thenReturn(FhirContext.forR5Cached()); + org.hl7.fhir.r5.model.Bundle bundle = new org.hl7.fhir.r5.model.Bundle(); + bundle.addEntry().setFullUrl(valueSet.getUrl()).setResource(valueSet); + when(mockRepository.search(any(), any(), any(), isNull())).thenReturn(bundle); + return mockRepository; + } + + Repository mockRepositoryWithValueSetDstu3(org.hl7.fhir.dstu3.model.ValueSet valueSet) { + var mockRepository = mock(Repository.class); + when(mockRepository.fhirContext()).thenReturn(FhirContext.forDstu3Cached()); + org.hl7.fhir.dstu3.model.Bundle bundle = new org.hl7.fhir.dstu3.model.Bundle(); + bundle.addEntry().setFullUrl(valueSet.getUrl()).setResource(valueSet); + when(mockRepository.search(any(), any(), any(), isNull())).thenReturn(bundle); + return mockRepository; + } +} diff --git a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/adapter/r4/MeasureAdapterTest.java b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/adapter/r4/MeasureAdapterTest.java index 522c94889..3f6d0a8ae 100644 --- a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/adapter/r4/MeasureAdapterTest.java +++ b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/adapter/r4/MeasureAdapterTest.java @@ -221,7 +221,7 @@ void adapter_get_all_dependencies_with_effective_data_requirements() { library.addDataRequirement().addCodeFilter().setValueSet(dependencies.get(3)); var measure = new Measure().addContained(new Patient()).addContained(library); measure.getMeta().addProfile(dependencies.get(4)); - measure.addExtension(Constants.CQFM_EFFECTIVE_DATA_REQUIREMENTS, new CanonicalType("#test")); + measure.addExtension(Constants.CQFM_EFFECTIVE_DATA_REQUIREMENTS, new Reference("#test")); var adapter = adapterFactory.createKnowledgeArtifactAdapter(measure); var extractedDependencies = adapter.getDependencies(); assertEquals(dependencies.size(), extractedDependencies.size()); diff --git a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/adapter/r5/MeasureAdapterTest.java b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/adapter/r5/MeasureAdapterTest.java index 51a745c8f..a3de0ce56 100644 --- a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/adapter/r5/MeasureAdapterTest.java +++ b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/adapter/r5/MeasureAdapterTest.java @@ -221,7 +221,7 @@ void adapter_get_all_dependencies_with_effective_data_requirements() { library.addDataRequirement().addCodeFilter().setValueSet(dependencies.get(3)); var measure = new Measure().addContained(new Patient()).addContained(library); measure.getMeta().addProfile(dependencies.get(4)); - measure.addExtension(Constants.CQFM_EFFECTIVE_DATA_REQUIREMENTS, new CanonicalType("#test")); + measure.addExtension(Constants.CQFM_EFFECTIVE_DATA_REQUIREMENTS, new Reference("#test")); var adapter = adapterFactory.createKnowledgeArtifactAdapter(measure); var extractedDependencies = adapter.getDependencies(); assertEquals(dependencies.size(), extractedDependencies.size()); diff --git a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/dstu3/ReleaseVisitorTests.java b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/dstu3/ReleaseVisitorTests.java index 410e579f0..9e7c5f7a5 100644 --- a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/dstu3/ReleaseVisitorTests.java +++ b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/dstu3/ReleaseVisitorTests.java @@ -29,26 +29,33 @@ import org.hl7.fhir.dstu3.model.Bundle; import org.hl7.fhir.dstu3.model.Bundle.BundleEntryComponent; import org.hl7.fhir.dstu3.model.CodeType; +import org.hl7.fhir.dstu3.model.DateType; import org.hl7.fhir.dstu3.model.Extension; import org.hl7.fhir.dstu3.model.IdType; import org.hl7.fhir.dstu3.model.Library; +import org.hl7.fhir.dstu3.model.Measure; import org.hl7.fhir.dstu3.model.Parameters; import org.hl7.fhir.dstu3.model.Period; import org.hl7.fhir.dstu3.model.RelatedArtifact; import org.hl7.fhir.dstu3.model.SearchParameter; import org.hl7.fhir.dstu3.model.StringType; +import org.hl7.fhir.dstu3.model.UriType; import org.hl7.fhir.exceptions.FHIRException; +import org.hl7.fhir.instance.model.api.IPrimitiveType; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; import org.opencds.cqf.fhir.api.Repository; +import org.opencds.cqf.fhir.utility.Canonicals; +import org.opencds.cqf.fhir.utility.Constants; import org.opencds.cqf.fhir.utility.adapter.KnowledgeArtifactAdapter; import org.opencds.cqf.fhir.utility.adapter.LibraryAdapter; import org.opencds.cqf.fhir.utility.adapter.dstu3.AdapterFactory; import org.opencds.cqf.fhir.utility.dstu3.MetadataResourceHelper; import org.opencds.cqf.fhir.utility.repository.InMemoryFhirRepository; import org.opencds.cqf.fhir.utility.visitor.ReleaseVisitor; +import org.opencds.cqf.fhir.utility.visitor.VisitorHelper; import org.slf4j.LoggerFactory; class ReleaseVisitorTests { @@ -90,6 +97,186 @@ public Bundle answer(InvocationOnMock a) throws Throwable { .transaction(any()); } + @Test + void visitMeasureCollectionTest() { + Bundle bundle = (Bundle) jsonParser.parseResource( + ReleaseVisitorTests.class.getResourceAsStream("Bundle-ecqm-qicore-2024-simplified.json")); + spyRepository.transaction(bundle); + Library library = spyRepository + .read(Library.class, new IdType("Library/ecqm-update-2024-05-02")) + .copy(); + + LibraryAdapter libraryAdapter = new AdapterFactory().createLibrary(library); + Parameters params = new Parameters(); + var versionParam = params.addParameter(); + versionParam.setName("version").setValue(new StringType("1.0.0")); + var versionBehaviourParam = params.addParameter(); + versionBehaviourParam.setName("versionBehavior").setValue(new StringType("default")); + + ReleaseVisitor releaseVisitor = new ReleaseVisitor(); + // Approval date is required to release an artifact + library.setApprovalDateElement(new DateType("2024-04-23")); + // Set the ID to Manifest-Release + Bundle returnResource = (Bundle) libraryAdapter.accept(releaseVisitor, spyRepository, params); + assertNotNull(returnResource); + Optional maybeLib = returnResource.getEntry().stream() + .filter(entry -> entry.getResponse().getLocation().contains("Library")) + .findFirst(); + assertTrue(maybeLib.isPresent()); + Library releasedLibrary = spyRepository.read( + Library.class, new IdType(maybeLib.get().getResponse().getLocation())); + var dependenciesOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.DEPENDSON)) + .collect(Collectors.toList()); + var componentsOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.COMPOSEDOF)) + .collect(Collectors.toList()); + // resolvable resources get descriptors + for (final var dependency : dependenciesOnReleasedArtifact) { + if (dependency + .getResource() + .getReference() + .equals("https://madie.cms.gov/Library/BreastCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Library BreastCancerScreeningFHIR, 0.0.001")); + } + if (dependency.getResource().equals("https://madie.cms.gov/Measure/BreastCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Measure Breast Cancer ScreeningFHIR, 0.0.001")); + } + if (dependency + .getResource() + .getReference() + .equals("https://madie.cms.gov/Library/CervicalCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Library CervicalCancerScreeningFHIR, 0.0.001")); + } + if (dependency + .getResource() + .getReference() + .equals("https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Measure Cervical Cancer ScreeningFHIR, 0.0.001")); + } + // expansion params versions should be used + if (Canonicals.getUrl(dependency.getResource().getReference()) != null + && Canonicals.getUrl(dependency.getResource().getReference()) + .equals("http://loinc.org")) { + assertNotNull(Canonicals.getVersion(dependency.getResource().getReference())); + assertTrue(Canonicals.getVersion(dependency.getResource().getReference()) + .equals("2.76")); + } + if (Canonicals.getUrl(dependency.getResource().getReference()) != null + && Canonicals.getUrl(dependency.getResource().getReference()) + .equals("http://snomed.info/sct")) { + assertNotNull(Canonicals.getVersion(dependency.getResource().getReference())); + assertTrue(Canonicals.getVersion(dependency.getResource().getReference()) + .equals("http://snomed.info/sct/731000124108/version/20230901")); + } + } + assertEquals(56, dependenciesOnReleasedArtifact.size()); + assertEquals(2, componentsOnReleasedArtifact.size()); + } + + @Test + void visitMeasureEffectiveDataRequirementsTest() { + Bundle bundle = (Bundle) jsonParser.parseResource( + ReleaseVisitorTests.class.getResourceAsStream("Bundle-ecqm-qicore-2024-simplified.json")); + spyRepository.transaction(bundle); + Library library = spyRepository + .read(Library.class, new IdType("Library/ecqm-update-2024-05-02")) + .copy(); + Measure CervicalCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/CervicalCancerScreeningFHIR")); + Measure BreastCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/BreastCancerScreeningFHIR")); + LibraryAdapter libraryAdapter = new AdapterFactory().createLibrary(library); + Parameters params = new Parameters(); + var versionParam = params.addParameter(); + versionParam.setName("version").setValue(new StringType("1.0.0")); + var versionBehaviourParam = params.addParameter(); + versionBehaviourParam.setName("versionBehavior").setValue(new StringType("default")); + + ReleaseVisitor releaseVisitor = new ReleaseVisitor(); + // Approval date is required to release an artifact + library.setApprovalDateElement(new DateType("2024-04-23")); + // removing the effectiveDataRequirements changes the dependency count + CervicalCancerScreeningFHIR.setContained(null); + spyRepository.update(CervicalCancerScreeningFHIR); + BreastCancerScreeningFHIR.setContained(null); + spyRepository.update(BreastCancerScreeningFHIR); + + Bundle returnResource = (Bundle) libraryAdapter.accept(releaseVisitor, spyRepository, params); + assertNotNull(returnResource); + Optional maybeLib = returnResource.getEntry().stream() + .filter(entry -> entry.getResponse().getLocation().contains("Library")) + .findFirst(); + assertTrue(maybeLib.isPresent()); + Library releasedLibrary = spyRepository.read( + Library.class, new IdType(maybeLib.get().getResponse().getLocation())); + var dependenciesOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.DEPENDSON)) + .collect(Collectors.toList()); + var componentsOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.COMPOSEDOF)) + .collect(Collectors.toList()); + + assertEquals(67, dependenciesOnReleasedArtifact.size()); + assertEquals(2, componentsOnReleasedArtifact.size()); + } + + @Test + void bothCRMIandCQFMEffectiveDataRequirementsTest() { + Bundle bundle = (Bundle) jsonParser.parseResource( + ReleaseVisitorTests.class.getResourceAsStream("Bundle-ecqm-qicore-2024-simplified.json")); + spyRepository.transaction(bundle); + Library library = spyRepository + .read(Library.class, new IdType("Library/ecqm-update-2024-05-02")) + .copy(); + Measure CervicalCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/CervicalCancerScreeningFHIR")); + Measure BreastCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/BreastCancerScreeningFHIR")); + LibraryAdapter libraryAdapter = new AdapterFactory().createLibrary(library); + Parameters params = new Parameters(); + params.addParameter().setName("version").setValue(new StringType("1.0.0")); + params.addParameter().setName("versionBehavior").setValue(new CodeType("default")); + var crmiEDRId = "exp-params-crmi-test"; + var crmiEDRExtension = new Extension(); + crmiEDRExtension.setUrl(Constants.CRMI_EFFECTIVE_DATA_REQUIREMENTS); + crmiEDRExtension.setValue(new UriType("#" + crmiEDRId)); + ReleaseVisitor releaseVisitor = new ReleaseVisitor(); + // Approval date is required to release an artifact + library.setApprovalDateElement(new DateType("2024-04-23")); + // if both cqfm and crmi effective data requirements are present then they will each be traced + var crmiEDRCervical = CervicalCancerScreeningFHIR.getContained().get(0).copy(); + crmiEDRCervical.setId(crmiEDRId); + CervicalCancerScreeningFHIR.addContained(crmiEDRCervical); + CervicalCancerScreeningFHIR.addExtension(crmiEDRExtension); + var crmiEDRBreastCancer = + BreastCancerScreeningFHIR.getContained().get(0).copy(); + crmiEDRBreastCancer.setId(crmiEDRId); + BreastCancerScreeningFHIR.addContained(crmiEDRBreastCancer); + BreastCancerScreeningFHIR.addExtension(crmiEDRExtension); + spyRepository.update(CervicalCancerScreeningFHIR); + spyRepository.update(BreastCancerScreeningFHIR); + + Bundle returnResource = (Bundle) libraryAdapter.accept(releaseVisitor, spyRepository, params); + assertNotNull(returnResource); + Optional maybeLib = returnResource.getEntry().stream() + .filter(entry -> entry.getResponse().getLocation().contains("Library")) + .findFirst(); + assertTrue(maybeLib.isPresent()); + Library releasedLibrary = spyRepository.read( + Library.class, new IdType(maybeLib.get().getResponse().getLocation())); + var dependenciesOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.DEPENDSON)) + .collect(Collectors.toList()); + var componentsOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.COMPOSEDOF)) + .collect(Collectors.toList()); + + // this should be 69, but we're not handling contained reference correctly + assertEquals(68, dependenciesOnReleasedArtifact.size()); + assertEquals(2, componentsOnReleasedArtifact.size()); + } + @Test void visitLibraryTest() { Bundle bundle = (Bundle) jsonParser.parseResource( @@ -174,7 +361,11 @@ void visitLibraryTest() { "http://hl7.org/fhir/us/ecr/StructureDefinition/ersd-plandefinition", "http://hl7.org/fhir/us/ecr/StructureDefinition/us-ph-plandefinition", "http://hl7.org/fhir/us/ecr/StructureDefinition/ersd-valueset", - "http://hl7.org/fhir/us/ecr/StructureDefinition/us-ph-triggering-valueset"); + "http://hl7.org/fhir/us/ecr/StructureDefinition/us-ph-triggering-valueset", + "http://snomed.info/sct", + "http://hl7.org/fhir/sid/icd-10-cm", + "http://loinc.org", + "http://www.nlm.nih.gov/research/umls/rxnorm"); var expectedErsdTestArtifactComponents = Arrays.asList( "http://ersd.aimsplatform.org/fhir/PlanDefinition/release-us-ecr-specification|" + existingVersion, "http://ersd.aimsplatform.org/fhir/Library/release-rctc|" + existingVersion, @@ -198,6 +389,54 @@ void visitLibraryTest() { // has extra groupers and rctc dependencies assertEquals(expectedErsdTestArtifactDependencies.size(), dependenciesOnReleasedArtifact.size()); assertEquals(expectedErsdTestArtifactComponents.size(), componentsOnReleasedArtifact.size()); + + var expansionParameters = + new AdapterFactory().createLibrary(releasedLibrary).getExpansionParameters(); + var systemVersionParams = expansionParameters + .map(p -> VisitorHelper.getListParameter("system-version", p, IPrimitiveType.class) + .orElse(null)) + .map(versions -> + versions.stream().map(v -> (String) v.getValue()).collect(Collectors.toList())) + .orElse(new ArrayList()); + var canonicalVersionParams = expansionParameters + .map(p -> VisitorHelper.getListParameter("canonical-version", p, IPrimitiveType.class) + .orElse(null)) + .map(versions -> + versions.stream().map(v -> (String) v.getValue()).collect(Collectors.toList())) + .orElse(new ArrayList()); + var expectedNewCanonicalVersionParams = Arrays.asList( + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.6|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1063|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.360|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.120|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.362|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.528|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.408|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.409|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1469|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1866|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1906|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.480|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.481|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.761|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1223|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1182|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1181|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1184|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1601|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1600|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1603|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1602|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1082|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1439|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1436|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1435|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1446|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1438|2022-10-19"); + assertEquals(expectedNewCanonicalVersionParams.size(), canonicalVersionParams.size()); + for (final var expected : expectedNewCanonicalVersionParams) { + assertTrue(canonicalVersionParams.stream().anyMatch(p -> p.equals(expected))); + } } @Test diff --git a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/r4/ReleaseVisitorTests.java b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/r4/ReleaseVisitorTests.java index dabf6c6d5..0a52324f8 100644 --- a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/r4/ReleaseVisitorTests.java +++ b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/r4/ReleaseVisitorTests.java @@ -26,13 +26,17 @@ import java.util.Optional; import java.util.stream.Collectors; import org.hl7.fhir.exceptions.FHIRException; +import org.hl7.fhir.instance.model.api.IPrimitiveType; import org.hl7.fhir.r4.model.BooleanType; import org.hl7.fhir.r4.model.Bundle; import org.hl7.fhir.r4.model.Bundle.BundleEntryComponent; +import org.hl7.fhir.r4.model.CanonicalType; import org.hl7.fhir.r4.model.CodeType; +import org.hl7.fhir.r4.model.DateType; import org.hl7.fhir.r4.model.Extension; import org.hl7.fhir.r4.model.IdType; import org.hl7.fhir.r4.model.Library; +import org.hl7.fhir.r4.model.Measure; import org.hl7.fhir.r4.model.Parameters; import org.hl7.fhir.r4.model.Period; import org.hl7.fhir.r4.model.RelatedArtifact; @@ -44,12 +48,14 @@ import org.mockito.stubbing.Answer; import org.opencds.cqf.fhir.api.Repository; import org.opencds.cqf.fhir.utility.Canonicals; +import org.opencds.cqf.fhir.utility.Constants; import org.opencds.cqf.fhir.utility.adapter.KnowledgeArtifactAdapter; import org.opencds.cqf.fhir.utility.adapter.LibraryAdapter; import org.opencds.cqf.fhir.utility.adapter.r4.AdapterFactory; import org.opencds.cqf.fhir.utility.r4.MetadataResourceHelper; import org.opencds.cqf.fhir.utility.repository.InMemoryFhirRepository; import org.opencds.cqf.fhir.utility.visitor.ReleaseVisitor; +import org.opencds.cqf.fhir.utility.visitor.VisitorHelper; import org.slf4j.LoggerFactory; class ReleaseVisitorTests { @@ -91,6 +97,170 @@ public Bundle answer(InvocationOnMock a) throws Throwable { .transaction(any()); } + @Test + void visitMeasureCollectionTest() { + Bundle bundle = (Bundle) jsonParser.parseResource( + ReleaseVisitorTests.class.getResourceAsStream("Bundle-ecqm-qicore-2024-simplified.json")); + spyRepository.transaction(bundle); + Library library = spyRepository + .read(Library.class, new IdType("Library/ecqm-update-2024-05-02")) + .copy(); + + LibraryAdapter libraryAdapter = new AdapterFactory().createLibrary(library); + Parameters params = new Parameters(); + params.addParameter("version", "1.0.0"); + params.addParameter("versionBehavior", new CodeType("default")); + + ReleaseVisitor releaseVisitor = new ReleaseVisitor(); + // Approval date is required to release an artifact + library.setApprovalDateElement(new DateType("2024-04-23")); + // Set the ID to Manifest-Release + Bundle returnResource = (Bundle) libraryAdapter.accept(releaseVisitor, spyRepository, params); + assertNotNull(returnResource); + Optional maybeLib = returnResource.getEntry().stream() + .filter(entry -> entry.getResponse().getLocation().contains("Library")) + .findFirst(); + assertTrue(maybeLib.isPresent()); + Library releasedLibrary = spyRepository.read( + Library.class, new IdType(maybeLib.get().getResponse().getLocation())); + var dependenciesOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.DEPENDSON)) + .collect(Collectors.toList()); + var componentsOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.COMPOSEDOF)) + .collect(Collectors.toList()); + // resolvable resources get descriptors + for (final var dependency : dependenciesOnReleasedArtifact) { + if (dependency.getResource().equals("https://madie.cms.gov/Library/BreastCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Library BreastCancerScreeningFHIR, 0.0.001")); + } + if (dependency.getResource().equals("https://madie.cms.gov/Measure/BreastCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Measure Breast Cancer ScreeningFHIR, 0.0.001")); + } + if (dependency.getResource().equals("https://madie.cms.gov/Library/CervicalCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Library CervicalCancerScreeningFHIR, 0.0.001")); + } + if (dependency.getResource().equals("https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Measure Cervical Cancer ScreeningFHIR, 0.0.001")); + } + // expansion params versions should be used + if (Canonicals.getUrl(dependency.getResource()) != null + && Canonicals.getUrl(dependency.getResource()).equals("http://loinc.org")) { + assertNotNull(Canonicals.getVersion(dependency.getResource())); + assertTrue(Canonicals.getVersion(dependency.getResource()).equals("2.76")); + } + if (Canonicals.getUrl(dependency.getResource()) != null + && Canonicals.getUrl(dependency.getResource()).equals("http://snomed.info/sct")) { + assertNotNull(Canonicals.getVersion(dependency.getResource())); + assertTrue(Canonicals.getVersion(dependency.getResource()) + .equals("http://snomed.info/sct/731000124108/version/20230901")); + } + } + assertEquals(56, dependenciesOnReleasedArtifact.size()); + assertEquals(2, componentsOnReleasedArtifact.size()); + } + + @Test + void visitMeasureEffectiveDataRequirementsTest() { + Bundle bundle = (Bundle) jsonParser.parseResource( + ReleaseVisitorTests.class.getResourceAsStream("Bundle-ecqm-qicore-2024-simplified.json")); + spyRepository.transaction(bundle); + Library library = spyRepository + .read(Library.class, new IdType("Library/ecqm-update-2024-05-02")) + .copy(); + Measure CervicalCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/CervicalCancerScreeningFHIR")); + Measure BreastCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/BreastCancerScreeningFHIR")); + LibraryAdapter libraryAdapter = new AdapterFactory().createLibrary(library); + Parameters params = new Parameters(); + params.addParameter("version", "1.0.0"); + params.addParameter("versionBehavior", new CodeType("default")); + + ReleaseVisitor releaseVisitor = new ReleaseVisitor(); + // Approval date is required to release an artifact + library.setApprovalDateElement(new DateType("2024-04-23")); + // removing the effectiveDataRequirements changes the dependency count + CervicalCancerScreeningFHIR.setContained(null); + spyRepository.update(CervicalCancerScreeningFHIR); + BreastCancerScreeningFHIR.setContained(null); + spyRepository.update(BreastCancerScreeningFHIR); + + Bundle returnResource = (Bundle) libraryAdapter.accept(releaseVisitor, spyRepository, params); + assertNotNull(returnResource); + Optional maybeLib = returnResource.getEntry().stream() + .filter(entry -> entry.getResponse().getLocation().contains("Library")) + .findFirst(); + assertTrue(maybeLib.isPresent()); + Library releasedLibrary = spyRepository.read( + Library.class, new IdType(maybeLib.get().getResponse().getLocation())); + var dependenciesOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.DEPENDSON)) + .collect(Collectors.toList()); + var componentsOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.COMPOSEDOF)) + .collect(Collectors.toList()); + + assertEquals(71, dependenciesOnReleasedArtifact.size()); + assertEquals(2, componentsOnReleasedArtifact.size()); + } + + @Test + void bothCRMIandCQFMEffectiveDataRequirementsTest() { + Bundle bundle = (Bundle) jsonParser.parseResource( + ReleaseVisitorTests.class.getResourceAsStream("Bundle-ecqm-qicore-2024-simplified.json")); + spyRepository.transaction(bundle); + Library library = spyRepository + .read(Library.class, new IdType("Library/ecqm-update-2024-05-02")) + .copy(); + Measure CervicalCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/CervicalCancerScreeningFHIR")); + Measure BreastCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/BreastCancerScreeningFHIR")); + LibraryAdapter libraryAdapter = new AdapterFactory().createLibrary(library); + Parameters params = new Parameters(); + params.addParameter("version", "1.0.0"); + params.addParameter("versionBehavior", new CodeType("default")); + var crmiEDRId = "exp-params-crmi-test"; + var crmiEDRExtension = new Extension(); + crmiEDRExtension.setUrl(Constants.CRMI_EFFECTIVE_DATA_REQUIREMENTS); + crmiEDRExtension.setValue(new CanonicalType("#" + crmiEDRId)); + ReleaseVisitor releaseVisitor = new ReleaseVisitor(); + // Approval date is required to release an artifact + library.setApprovalDateElement(new DateType("2024-04-23")); + // if both cqfm and crmi effective data requirements are present then they will each be traced + var crmiEDRCervical = CervicalCancerScreeningFHIR.getContained().get(0).copy(); + crmiEDRCervical.setId(crmiEDRId); + CervicalCancerScreeningFHIR.addContained(crmiEDRCervical); + CervicalCancerScreeningFHIR.addExtension(crmiEDRExtension); + var crmiEDRBreastCancer = + BreastCancerScreeningFHIR.getContained().get(0).copy(); + crmiEDRBreastCancer.setId(crmiEDRId); + BreastCancerScreeningFHIR.addContained(crmiEDRBreastCancer); + BreastCancerScreeningFHIR.addExtension(crmiEDRExtension); + spyRepository.update(CervicalCancerScreeningFHIR); + spyRepository.update(BreastCancerScreeningFHIR); + + Bundle returnResource = (Bundle) libraryAdapter.accept(releaseVisitor, spyRepository, params); + assertNotNull(returnResource); + Optional maybeLib = returnResource.getEntry().stream() + .filter(entry -> entry.getResponse().getLocation().contains("Library")) + .findFirst(); + assertTrue(maybeLib.isPresent()); + Library releasedLibrary = spyRepository.read( + Library.class, new IdType(maybeLib.get().getResponse().getLocation())); + var dependenciesOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.DEPENDSON)) + .collect(Collectors.toList()); + var componentsOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.COMPOSEDOF)) + .collect(Collectors.toList()); + + // this should be 73, but we're not handling contained reference correctly + assertEquals(72, dependenciesOnReleasedArtifact.size()); + assertEquals(2, componentsOnReleasedArtifact.size()); + } + @Test void visitLibraryTest() { Bundle bundle = (Bundle) jsonParser.parseResource( @@ -175,7 +345,11 @@ void visitLibraryTest() { "http://hl7.org/fhir/us/ecr/StructureDefinition/ersd-plandefinition", "http://hl7.org/fhir/us/ecr/StructureDefinition/us-ph-plandefinition", "http://hl7.org/fhir/us/ecr/StructureDefinition/ersd-valueset", - "http://hl7.org/fhir/us/ecr/StructureDefinition/us-ph-triggering-valueset"); + "http://hl7.org/fhir/us/ecr/StructureDefinition/us-ph-triggering-valueset", + "http://www.nlm.nih.gov/research/umls/rxnorm", + "http://loinc.org", + "http://hl7.org/fhir/sid/icd-10-cm", + "http://snomed.info/sct"); var expectedErsdTestArtifactComponents = Arrays.asList( "http://ersd.aimsplatform.org/fhir/PlanDefinition/release-us-ecr-specification|" + existingVersion, "http://ersd.aimsplatform.org/fhir/Library/release-rctc|" + existingVersion, @@ -199,6 +373,54 @@ void visitLibraryTest() { // ensure it only has the expected components and dependencies assertEquals(expectedErsdTestArtifactDependencies.size(), dependenciesOnReleasedArtifact.size()); assertEquals(expectedErsdTestArtifactComponents.size(), componentsOnReleasedArtifact.size()); + + var expansionParameters = + new AdapterFactory().createLibrary(releasedLibrary).getExpansionParameters(); + var systemVersionParams = expansionParameters + .map(p -> VisitorHelper.getListParameter("system-version", p, IPrimitiveType.class) + .orElse(null)) + .map(versions -> + versions.stream().map(v -> (String) v.getValue()).collect(Collectors.toList())) + .orElse(new ArrayList()); + var canonicalVersionParams = expansionParameters + .map(p -> VisitorHelper.getListParameter("canonical-version", p, IPrimitiveType.class) + .orElse(null)) + .map(versions -> + versions.stream().map(v -> (String) v.getValue()).collect(Collectors.toList())) + .orElse(new ArrayList()); + var expectedNewCanonicalVersionParams = Arrays.asList( + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.6|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1063|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.360|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.120|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.362|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.528|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.408|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.409|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1469|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1866|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1906|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.480|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.481|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.761|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1223|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1182|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1181|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1184|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1601|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1600|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1603|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1602|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1082|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1439|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1436|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1435|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1446|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1438|2022-10-19"); + assertEquals(expectedNewCanonicalVersionParams.size(), canonicalVersionParams.size()); + for (final var expected : expectedNewCanonicalVersionParams) { + assertTrue(canonicalVersionParams.stream().anyMatch(p -> p.equals(expected))); + } } @Test diff --git a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/r5/ReleaseVisitorTests.java b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/r5/ReleaseVisitorTests.java index a4d969257..eb0686072 100644 --- a/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/r5/ReleaseVisitorTests.java +++ b/cqf-fhir-utility/src/test/java/org/opencds/cqf/fhir/utility/visitor/r5/ReleaseVisitorTests.java @@ -26,13 +26,17 @@ import java.util.Optional; import java.util.stream.Collectors; import org.hl7.fhir.exceptions.FHIRException; +import org.hl7.fhir.instance.model.api.IPrimitiveType; import org.hl7.fhir.r5.model.BooleanType; import org.hl7.fhir.r5.model.Bundle; import org.hl7.fhir.r5.model.Bundle.BundleEntryComponent; +import org.hl7.fhir.r5.model.CanonicalType; import org.hl7.fhir.r5.model.CodeType; +import org.hl7.fhir.r5.model.DateType; import org.hl7.fhir.r5.model.Extension; import org.hl7.fhir.r5.model.IdType; import org.hl7.fhir.r5.model.Library; +import org.hl7.fhir.r5.model.Measure; import org.hl7.fhir.r5.model.Parameters; import org.hl7.fhir.r5.model.Period; import org.hl7.fhir.r5.model.RelatedArtifact; @@ -43,12 +47,15 @@ import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; import org.opencds.cqf.fhir.api.Repository; +import org.opencds.cqf.fhir.utility.Canonicals; +import org.opencds.cqf.fhir.utility.Constants; import org.opencds.cqf.fhir.utility.adapter.KnowledgeArtifactAdapter; import org.opencds.cqf.fhir.utility.adapter.LibraryAdapter; import org.opencds.cqf.fhir.utility.adapter.r5.AdapterFactory; import org.opencds.cqf.fhir.utility.r5.MetadataResourceHelper; import org.opencds.cqf.fhir.utility.repository.InMemoryFhirRepository; import org.opencds.cqf.fhir.utility.visitor.ReleaseVisitor; +import org.opencds.cqf.fhir.utility.visitor.VisitorHelper; import org.slf4j.LoggerFactory; class ReleaseVisitorTests { @@ -90,6 +97,170 @@ public Bundle answer(InvocationOnMock a) throws Throwable { .transaction(any()); } + @Test + void visitMeasureCollectionTest() { + Bundle bundle = (Bundle) jsonParser.parseResource( + ReleaseVisitorTests.class.getResourceAsStream("Bundle-ecqm-qicore-2024-simplified.json")); + spyRepository.transaction(bundle); + Library library = spyRepository + .read(Library.class, new IdType("Library/ecqm-update-2024-05-02")) + .copy(); + + LibraryAdapter libraryAdapter = new AdapterFactory().createLibrary(library); + Parameters params = new Parameters(); + params.addParameter("version", "1.0.0"); + params.addParameter("versionBehavior", new CodeType("default")); + + ReleaseVisitor releaseVisitor = new ReleaseVisitor(); + // Approval date is required to release an artifact + library.setApprovalDateElement(new DateType("2024-04-23")); + // Set the ID to Manifest-Release + Bundle returnResource = (Bundle) libraryAdapter.accept(releaseVisitor, spyRepository, params); + assertNotNull(returnResource); + Optional maybeLib = returnResource.getEntry().stream() + .filter(entry -> entry.getResponse().getLocation().contains("Library")) + .findFirst(); + assertTrue(maybeLib.isPresent()); + Library releasedLibrary = spyRepository.read( + Library.class, new IdType(maybeLib.get().getResponse().getLocation())); + var dependenciesOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.DEPENDSON)) + .collect(Collectors.toList()); + var componentsOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.COMPOSEDOF)) + .collect(Collectors.toList()); + // resolvable resources get descriptors + for (final var dependency : dependenciesOnReleasedArtifact) { + if (dependency.getResource().equals("https://madie.cms.gov/Library/BreastCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Library BreastCancerScreeningFHIR, 0.0.001")); + } + if (dependency.getResource().equals("https://madie.cms.gov/Measure/BreastCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Measure Breast Cancer ScreeningFHIR, 0.0.001")); + } + if (dependency.getResource().equals("https://madie.cms.gov/Library/CervicalCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Library CervicalCancerScreeningFHIR, 0.0.001")); + } + if (dependency.getResource().equals("https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR|0.0.001")) { + assertTrue(dependency.getDisplay().equals("Measure Cervical Cancer ScreeningFHIR, 0.0.001")); + } + // expansion params versions should be used + if (Canonicals.getUrl(dependency.getResource()) != null + && Canonicals.getUrl(dependency.getResource()).equals("http://loinc.org")) { + assertNotNull(Canonicals.getVersion(dependency.getResource())); + assertTrue(Canonicals.getVersion(dependency.getResource()).equals("2.76")); + } + if (Canonicals.getUrl(dependency.getResource()) != null + && Canonicals.getUrl(dependency.getResource()).equals("http://snomed.info/sct")) { + assertNotNull(Canonicals.getVersion(dependency.getResource())); + assertTrue(Canonicals.getVersion(dependency.getResource()) + .equals("http://snomed.info/sct/731000124108/version/20230901")); + } + } + assertEquals(56, dependenciesOnReleasedArtifact.size()); + assertEquals(2, componentsOnReleasedArtifact.size()); + } + + @Test + void visitMeasureEffectiveDataRequirementsTest() { + Bundle bundle = (Bundle) jsonParser.parseResource( + ReleaseVisitorTests.class.getResourceAsStream("Bundle-ecqm-qicore-2024-simplified.json")); + spyRepository.transaction(bundle); + Library library = spyRepository + .read(Library.class, new IdType("Library/ecqm-update-2024-05-02")) + .copy(); + Measure CervicalCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/CervicalCancerScreeningFHIR")); + Measure BreastCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/BreastCancerScreeningFHIR")); + LibraryAdapter libraryAdapter = new AdapterFactory().createLibrary(library); + Parameters params = new Parameters(); + params.addParameter("version", "1.0.0"); + params.addParameter("versionBehavior", new CodeType("default")); + + ReleaseVisitor releaseVisitor = new ReleaseVisitor(); + // Approval date is required to release an artifact + library.setApprovalDateElement(new DateType("2024-04-23")); + // removing the effectiveDataRequirements changes the dependency count + CervicalCancerScreeningFHIR.setContained(null); + spyRepository.update(CervicalCancerScreeningFHIR); + BreastCancerScreeningFHIR.setContained(null); + spyRepository.update(BreastCancerScreeningFHIR); + + Bundle returnResource = (Bundle) libraryAdapter.accept(releaseVisitor, spyRepository, params); + assertNotNull(returnResource); + Optional maybeLib = returnResource.getEntry().stream() + .filter(entry -> entry.getResponse().getLocation().contains("Library")) + .findFirst(); + assertTrue(maybeLib.isPresent()); + Library releasedLibrary = spyRepository.read( + Library.class, new IdType(maybeLib.get().getResponse().getLocation())); + var dependenciesOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.DEPENDSON)) + .collect(Collectors.toList()); + var componentsOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.COMPOSEDOF)) + .collect(Collectors.toList()); + + assertEquals(71, dependenciesOnReleasedArtifact.size()); + assertEquals(2, componentsOnReleasedArtifact.size()); + } + + @Test + void bothCRMIandCQFMEffectiveDataRequirementsTest() { + Bundle bundle = (Bundle) jsonParser.parseResource( + ReleaseVisitorTests.class.getResourceAsStream("Bundle-ecqm-qicore-2024-simplified.json")); + spyRepository.transaction(bundle); + Library library = spyRepository + .read(Library.class, new IdType("Library/ecqm-update-2024-05-02")) + .copy(); + Measure CervicalCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/CervicalCancerScreeningFHIR")); + Measure BreastCancerScreeningFHIR = + spyRepository.read(Measure.class, new IdType("Measure/BreastCancerScreeningFHIR")); + LibraryAdapter libraryAdapter = new AdapterFactory().createLibrary(library); + Parameters params = new Parameters(); + params.addParameter("version", "1.0.0"); + params.addParameter("versionBehavior", new CodeType("default")); + var crmiEDRId = "exp-params-crmi-test"; + var crmiEDRExtension = new Extension(); + crmiEDRExtension.setUrl(Constants.CRMI_EFFECTIVE_DATA_REQUIREMENTS); + crmiEDRExtension.setValue(new CanonicalType("#" + crmiEDRId)); + ReleaseVisitor releaseVisitor = new ReleaseVisitor(); + // Approval date is required to release an artifact + library.setApprovalDateElement(new DateType("2024-04-23")); + // if both cqfm and crmi effective data requirements are present then they will each be traced + var crmiEDRCervical = CervicalCancerScreeningFHIR.getContained().get(0).copy(); + crmiEDRCervical.setId(crmiEDRId); + CervicalCancerScreeningFHIR.addContained(crmiEDRCervical); + CervicalCancerScreeningFHIR.addExtension(crmiEDRExtension); + var crmiEDRBreastCancer = + BreastCancerScreeningFHIR.getContained().get(0).copy(); + crmiEDRBreastCancer.setId(crmiEDRId); + BreastCancerScreeningFHIR.addContained(crmiEDRBreastCancer); + BreastCancerScreeningFHIR.addExtension(crmiEDRExtension); + spyRepository.update(CervicalCancerScreeningFHIR); + spyRepository.update(BreastCancerScreeningFHIR); + + Bundle returnResource = (Bundle) libraryAdapter.accept(releaseVisitor, spyRepository, params); + assertNotNull(returnResource); + Optional maybeLib = returnResource.getEntry().stream() + .filter(entry -> entry.getResponse().getLocation().contains("Library")) + .findFirst(); + assertTrue(maybeLib.isPresent()); + Library releasedLibrary = spyRepository.read( + Library.class, new IdType(maybeLib.get().getResponse().getLocation())); + var dependenciesOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.DEPENDSON)) + .collect(Collectors.toList()); + var componentsOnReleasedArtifact = releasedLibrary.getRelatedArtifact().stream() + .filter(ra -> ra.getType().equals(RelatedArtifact.RelatedArtifactType.COMPOSEDOF)) + .collect(Collectors.toList()); + + // this should be 73, but we're not handling contained reference correctly + assertEquals(72, dependenciesOnReleasedArtifact.size()); + assertEquals(2, componentsOnReleasedArtifact.size()); + } + @Test void visitLibraryTest() { Bundle bundle = (Bundle) jsonParser.parseResource( @@ -172,7 +343,11 @@ void visitLibraryTest() { "http://hl7.org/fhir/us/ecr/StructureDefinition/ersd-plandefinition", "http://hl7.org/fhir/us/ecr/StructureDefinition/us-ph-plandefinition", "http://hl7.org/fhir/us/ecr/StructureDefinition/ersd-valueset", - "http://hl7.org/fhir/us/ecr/StructureDefinition/us-ph-triggering-valueset"); + "http://hl7.org/fhir/us/ecr/StructureDefinition/us-ph-triggering-valueset", + "http://snomed.info/sct", + "http://hl7.org/fhir/sid/icd-10-cm", + "http://loinc.org", + "http://www.nlm.nih.gov/research/umls/rxnorm"); var expectedErsdTestArtifactComponents = Arrays.asList( "http://ersd.aimsplatform.org/fhir/PlanDefinition/release-us-ecr-specification|" + existingVersion, "http://ersd.aimsplatform.org/fhir/Library/release-rctc|" + existingVersion, @@ -187,6 +362,9 @@ void visitLibraryTest() { .collect(Collectors.toList()); // check that the released artifact has all the required dependencies for (var dependency : expectedErsdTestArtifactDependencies) { + if (!dependenciesOnReleasedArtifact.contains(dependency)) { + var s = dependency; + } assertTrue(dependenciesOnReleasedArtifact.contains(dependency)); } // and components @@ -196,6 +374,54 @@ void visitLibraryTest() { // has extra groupers and rctc dependencies assertEquals(expectedErsdTestArtifactDependencies.size(), dependenciesOnReleasedArtifact.size()); assertEquals(expectedErsdTestArtifactComponents.size(), componentsOnReleasedArtifact.size()); + + var expansionParameters = + new AdapterFactory().createLibrary(releasedLibrary).getExpansionParameters(); + var systemVersionParams = expansionParameters + .map(p -> VisitorHelper.getListParameter("system-version", p, IPrimitiveType.class) + .orElse(null)) + .map(versions -> + versions.stream().map(v -> (String) v.getValue()).collect(Collectors.toList())) + .orElse(new ArrayList()); + var canonicalVersionParams = expansionParameters + .map(p -> VisitorHelper.getListParameter("canonical-version", p, IPrimitiveType.class) + .orElse(null)) + .map(versions -> + versions.stream().map(v -> (String) v.getValue()).collect(Collectors.toList())) + .orElse(new ArrayList()); + var expectedNewCanonicalVersionParams = Arrays.asList( + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.6|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1063|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.360|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.120|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.362|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.528|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.408|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.409|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1469|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1866|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1906|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.480|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.481|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.761|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1223|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1182|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1181|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1184|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1601|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1600|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1603|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1602|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1082|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1439|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1436|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1435|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1446|2022-10-19", + "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113762.1.4.1146.1438|2022-10-19"); + assertEquals(expectedNewCanonicalVersionParams.size(), canonicalVersionParams.size()); + for (final var expected : expectedNewCanonicalVersionParams) { + assertTrue(canonicalVersionParams.stream().anyMatch(p -> p.equals(expected))); + } } @Test diff --git a/cqf-fhir-utility/src/test/resources/org/opencds/cqf/fhir/utility/visitor/dstu3/Bundle-ecqm-qicore-2024-simplified.json b/cqf-fhir-utility/src/test/resources/org/opencds/cqf/fhir/utility/visitor/dstu3/Bundle-ecqm-qicore-2024-simplified.json new file mode 100644 index 000000000..78b72b67c --- /dev/null +++ b/cqf-fhir-utility/src/test/resources/org/opencds/cqf/fhir/utility/visitor/dstu3/Bundle-ecqm-qicore-2024-simplified.json @@ -0,0 +1,5466 @@ +{ + "resourceType": "Bundle", + "id": "ecqm-content-qicore-2024-subset-simplified-bundle", + "type": "transaction", + "timestamp": "2022-10-21T15:18:28.504-04:00", + "entry": [ + { + "fullUrl": "http://hl7.org/fhir/us/cqfmeasures/Library/ecqm-update-2024-05-02|1.0.0", + "resource": { + "resourceType": "Library", + "id": "ecqm-update-2024-05-02", + "meta": { + "profile": [ + "http://hl7.org/fhir/uv/crmi/StructureDefinition/crmi-manifestlibrary" + ] + }, + "contained": [ + { + "resourceType": "Parameters", + "id": "exp-params", + "parameter": [ + { + "name": "system-version", + "valueUri": "http://snomed.info/sct|http://snomed.info/sct/731000124108/version/20230901" + }, + { + "name": "system-version", + "valueUri": "http://loinc.org|2.76" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/v3-ActCode|9.0.0" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender|3.0.0" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/CD2|2.0.1" + }, + { + "name": "system-version", + "valueUri": "urn:oid:2.16.840.1.113883.6.238|1.2" + }, + { + "name": "system-version", + "valueUri": "http://www.ama-assn.org/go/cpt|3.0.1" + }, + { + "name": "system-version", + "valueUri": "http://hl7.org/fhir/sid/cvx|4.0.0" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/HCPCS-all-codes|3.0.0" + }, + { + "name": "system-version", + "valueUri": "http://www.cms.gov/Medicare/Coding/HCPCSReleaseCodeSets|1.0.2" + }, + { + "name": "system-version", + "valueUri": "http://hl7.org/fhir/sid/icd-10-cm|2.0.1" + }, + { + "name": "system-version", + "valueUri": "http://www.cms.gov/Medicare/Coding/ICD10|2.0.1" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/icd9cm|2.0.1" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/v2-0895|2.2.0" + }, + { + "name": "system-version", + "valueUri": "http://www.nlm.nih.gov/research/umls/rxnorm|3.0.1" + }, + { + "name": "system-version", + "valueUri": "https://nahdo.org/sopt|1.0.1" + } + ] + } + ], + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expansionParameters", + "valueReference": { + "reference": "#exp-params" + } + } + ], + "url": "http://hl7.org/fhir/us/cqfmeasures/Library/ecqm-update-2024-05-02", + "identifier": [ + { + "use": "official", + "system": "http://example.org/fhir/cqi/ecqm/Library/Identifier", + "value": "eCQM Update 2024-05-02" + } + ], + "version": "1.0.0", + "name": "ECQMUpdate20240502", + "title": "eCQM Update 2024-05-02", + "status": "draft", + "experimental": true, + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "asset-collection" + } + ] + }, + "date": "2024-04-23", + "publisher": "Clinical Quality Information WG", + "contact": [ + { + "telecom": [ + { + "system": "url", + "value": "http://www.hl7.org/Special/committees/cqi" + } + ] + } + ], + "description": "This library is an example final draft of a version manifest (also referred to as an expansion profile) that specifies expansion rules for a set of value sets used for an example set of EP/EC measures.", + "useContext": [ + { + "code": { + "system": "http://terminology.hl7.org/CodeSystem/usage-context-type", + "code": "program" + }, + "valueCodeableConcept": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/quality-programs", + "code": "ep-ec", + "display": "EP/EC" + } + ] + } + }, + { + "code": { + "system": "http://terminology.hl7.org/CodeSystem/usage-context-type", + "code": "program" + }, + "valueCodeableConcept": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/quality-programs", + "code": "eh-cah", + "display": "EH/CAH" + } + ] + } + } + ], + "jurisdiction": [ + { + "coding": [ + { + "system": "urn:iso:std:iso:3166", + "code": "US" + } + ] + } + ], + "purpose": "This library is defined to illustrate a Version Manifest in final draft status, as it would look at the end of an eCQM Annual Update cycle, approved on April 23rd, 2024. The latest available version of code systems used at that time is specified to provide stability for value set expansion during the testing and implementation phase. Terminology.HL7.org, in particular, was version 5.5.0 at the time, and FHIR code system versions are chosen from that release.", + "approvalDate": "2024-04-23", + "lastReviewDate": "2024-04-23", + "relatedArtifact": [ + { + "type": "composed-of", + "display": "Measure Cervical Cancer ScreeningFHIR, 0.0.001", + "resource": { + "reference": "https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR|0.0.001" + } + }, + { + "type": "composed-of", + "display": "Measure Breast Cancer ScreeningFHIR, 0.0.001", + "resource": { + "reference": "https://madie.cms.gov/Measure/BreastCancerScreeningFHIR|0.0.001" + } + } + ] + }, + "request": { + "method": "PUT", + "url": "Library/ecqm-update-2024-05-02" + } + }, + { + "fullUrl": "https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Measure", + "id": "CervicalCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/publishable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/executable-measure-cqfm" + ] + }, + "contained": [ + { + "resourceType": "Library", + "id": "effective-data-requirements", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/observation-category", + "code": "laboratory", + "display": "laboratory" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428361000124107", + "display": "Discharge to home for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428371000124100", + "display": "Discharge to healthcare facility for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/observation-category", + "code": "survey", + "display": "survey" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "373066001", + "display": "Yes (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Cervical Cytology Within 3 Years" + }, + { + "url": "statement", + "valueString": "define \"Cervical Cytology Within 3 Years\":\n ( ( [Observation: \"Pap Test\"] ).isLaboratoryTestPerformed ( ) ) CervicalCytology\n where CervicalCytology.effective.latest ( ) during day of Interval[start of \"Measurement Period\" - 2 years, end of \"Measurement Period\"]\n and CervicalCytology.value is not null" + }, + { + "url": "displaySequence", + "valueInteger": 0 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "HPV Test Within 5 Years for Women Age 30 and Older" + }, + { + "url": "statement", + "valueString": "define \"HPV Test Within 5 Years for Women Age 30 and Older\":\n ( ( [Observation: \"HPV Test\"] ).isLaboratoryTestPerformed ( ) ) HPVTest\n where AgeInYearsAt(date from HPVTest.effective.latest()) >= 30\n and HPVTest.effective.latest ( ) during day of Interval[start of \"Measurement Period\" - 4 years, end of \"Measurement Period\"]\n and HPVTest.value is not null" + }, + { + "url": "displaySequence", + "valueInteger": 1 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Numerator" + }, + { + "url": "statement", + "valueString": "define \"Numerator\":\n exists \"Cervical Cytology Within 3 Years\"\n or exists \"HPV Test Within 5 Years for Women Age 30 and Older\"" + }, + { + "url": "displaySequence", + "valueInteger": 2 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Qualifying Encounters" + }, + { + "url": "statement", + "valueString": "define \"Qualifying Encounters\":\n ( ( [\"Encounter\": \"Office Visit\"]\n union [Encounter: \"Preventive Care Services Established Office Visit, 18 and Up\"]\n union [Encounter: \"Preventive Care Services Initial Office Visit, 18 and Up\"]\n union [Encounter: \"Home Healthcare Services\"]\n union [Encounter: \"Telephone Visits\"]\n union [Encounter: \"Virtual Encounter\"]\n ).isEncounterPerformed ( ) ) ValidEncounters\n where ValidEncounters.period.toInterval ( ) during day of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 3 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Initial Population" + }, + { + "url": "statement", + "valueString": "define \"Initial Population\":\n AgeInYearsAt(date from \n end of \"Measurement Period\"\n ) in Interval[24, 64]\n and Patient.gender = 'female'\n and exists \"Qualifying Encounters\"" + }, + { + "url": "displaySequence", + "valueInteger": 4 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator" + }, + { + "url": "statement", + "valueString": "define \"Denominator\":\n \"Initial Population\"" + }, + { + "url": "displaySequence", + "valueInteger": 5 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Hospice" + }, + { + "url": "name", + "valueString": "Has Hospice Services" + }, + { + "url": "statement", + "valueString": "define \"Has Hospice Services\":\n exists ((([Encounter: \"Encounter Inpatient\"]).isEncounterPerformed()) InpatientEncounter\n where (InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to home for hospice care (procedure)\"\n or InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to healthcare facility for hospice care (procedure)\"\n )\n and InpatientEncounter.period.toInterval() ends during day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Hospice Encounter\"]).isEncounterPerformed()) HospiceEncounter\n where HospiceEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Observation: \"Hospice care [Minimum Data Set]\"]).isAssessmentPerformed()) HospiceAssessment\n where HospiceAssessment.value ~ \"Yes (qualifier value)\"\n and HospiceAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([ServiceRequest: \"Hospice Care Ambulatory\"]).isInterventionOrder()) HospiceOrder\n where HospiceOrder.authoredOn.toInterval() during day of \"Measurement Period\"\n // and HospiceOrder.doNotPerform is not true\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-447\n )\n or exists ((([Procedure: \"Hospice Care Ambulatory\"]).isInterventionPerformed()) HospicePerformed\n where HospicePerformed.performed.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists (([Condition: \"Hospice Diagnosis\"]) HospiceCareDiagnosis\n where HospiceCareDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 6 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Absence of Cervix" + }, + { + "url": "statement", + "valueString": "define \"Absence of Cervix\":\n ( ( ( [Procedure: \"Hysterectomy with No Residual Cervix\"] ).isProcedurePerformed ( ) ) NoCervixProcedure\n where NoCervixProcedure.performed.toInterval ( ) ends on or before end of \"Measurement Period\"\n )\n union ( [Condition: \"Congenital or Acquired Absence of Cervix\"] NoCervixDiagnosis\n where NoCervixDiagnosis.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 7 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "PalliativeCare" + }, + { + "url": "name", + "valueString": "Has Palliative Care in the Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Palliative Care in the Measurement Period\":\n exists ((([Observation: \"Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)\"]).isAssessmentPerformed()) PalliativeAssessment\n where PalliativeAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ([Condition: \"Palliative Care Diagnosis\"] PalliativeDiagnosis\n where PalliativeDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Palliative Care Encounter\"]).isEncounterPerformed()) PalliativeEncounter\n where PalliativeEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Procedure: \"Palliative Care Intervention\"]).isInterventionPerformed()) PalliativeIntervention\n where PalliativeIntervention.performed.toInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 8 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator Exclusions" + }, + { + "url": "statement", + "valueString": "define \"Denominator Exclusions\":\n Hospice.\"Has Hospice Services\"\n or exists \"Absence of Cervix\"\n or PalliativeCare.\"Has Palliative Care in the Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 9 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isLaboratoryTestPerformed" + }, + { + "url": "statement", + "valueString": "//Laboratory Test, Performed\ndefine fluent function isLaboratoryTestPerformed(Obs List):\n Obs O\n where O.status in { 'final', 'amended', 'corrected' }\n and exists ( O.category ObservationCategory\n where ( ObservationCategory ) ~ \"laboratory\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 10 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "FHIRHelpers" + }, + { + "url": "name", + "valueString": "ToConcept" + }, + { + "url": "statement", + "valueString": "/*\n@description: Converts the given FHIR [CodeableConcept](https://hl7.org/fhir/datatypes.html#CodeableConcept) value to a CQL Concept.\n*/\ndefine function ToConcept(concept FHIR.CodeableConcept):\n if concept is null then\n null\n else\n System.Concept {\n codes: concept.coding C return ToCode(C),\n display: concept.text.value\n }" + }, + { + "url": "displaySequence", + "valueInteger": 11 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "latest" + }, + { + "url": "statement", + "valueString": "/*\n@description: Given an interval, returns the ending point if the interval has an ending boundary specified,\notherwise, returns the starting point\n*/\ndefine fluent function latest(choice Choice, Interval> ):\n (choice.toInterval()) period\n return\n if (period.\"hasEnd\"()) then end of period\n else start of period" + }, + { + "url": "displaySequence", + "valueInteger": 12 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isEncounterPerformed" + }, + { + "url": "statement", + "valueString": "//Encounter, Performed\n//General usage unless required otherwise by measure intent (e.g., follow-up encounters)\ndefine fluent function isEncounterPerformed(Enc List):\n Enc E\n where E.status in {'finished', 'arrived', 'triaged', 'in-progress', 'onleave'}" + }, + { + "url": "displaySequence", + "valueInteger": 13 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "toInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval\n@comment: Normalizes a choice type of DateTime, Quanitty, Interval, or Interval types\nto an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible\nrepresentations for timing-valued elements in QICore, allowing this function to be used across any resource.\nThe input can be provided as a DateTime, Quantity, Interval or Interval.\nThe intent of this function is to provide a clear and concise mechanism to treat single\nelements that have multiple possible representations as intervals so that logic doesn't have to account\nfor the variability. More complex calculations (such as medication request period or dispense period\ncalculation) need specific guidance and consideration. That guidance may make use of this function, but\nthe focus of this function is on single element calculations where the semantics are unambiguous.\nIf the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.\nIf the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,\nand the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.\nIf the input is a DateTime Interval, the result is the input.\nIf the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result\nis a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending\nimmediately before one year later than the date the patient turned the age given as the end of the quantity interval.\nIf the input is a Timing, an error will be thrown indicating that Timing calculations are not implemented. Any other input will reslt in a null DateTime Interval\n*/\ndefine fluent function toInterval(choice Choice, Interval, Timing>):\n case\n\t when choice is DateTime then\n \tInterval[choice as DateTime, choice as DateTime]\n\t\twhen choice is Interval then\n \t\tchoice as Interval\n\t\twhen choice is Quantity then\n\t\t Interval[Patient.birthDate + (choice as Quantity),\n\t\t\t Patient.birthDate + (choice as Quantity) + 1 year)\n\t\twhen choice is Interval then\n\t\t Interval[Patient.birthDate + (choice.low as Quantity),\n\t\t\t Patient.birthDate + (choice.high as Quantity) + 1 year)\n\t\twhen choice is Timing then\n Message(null, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a Timing value is not supported') as Interval\n\t\telse\n\t\t\tnull as Interval\n\tend" + }, + { + "url": "displaySequence", + "valueInteger": 14 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isAssessmentPerformed" + }, + { + "url": "statement", + "valueString": "//This library contains functions that are based on QDM 5.6 to QICore 4.1.1 March 2023 (https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns---QICore-v4.1.1). The functions may appear similar to some QICoreCommon functions but different in that they have constraints that are relevant for measures authored by NCQA.\n\n//Assessment, Performed\ndefine fluent function isAssessmentPerformed(Obs List):\n Obs O\n where O.status in { 'final', 'amended', 'corrected' }\n and exists ( O.category ObservationCategory\n where ( ObservationCategory ) ~ \"survey\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 15 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionOrder" + }, + { + "url": "statement", + "valueString": "//Intervention, Order: active and completed only \ndefine fluent function isInterventionOrder(ServiceRequest List):\n ServiceRequest S\n where S.status in { 'active', 'completed' }\n and S.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 16 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionPerformed" + }, + { + "url": "statement", + "valueString": "//Intervention, Performed\ndefine fluent function isInterventionPerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 17 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "prevalenceInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Returns an interval representing the normalized prevalence period of a given Condition.\n@comment: Uses the ToInterval and ToAbatementInterval functions to determine the widest potential interval from\nonset to abatement as specified in the given Condition. If the condition is active, or has an abatement date the resulting \ninterval will have a closed ending boundary. Otherwise, the resulting interval will have an open ending boundary.\n*/\ndefine fluent function prevalenceInterval(condition Condition):\nif condition.clinicalStatus ~ \"active\"\n or condition.clinicalStatus ~ \"recurrence\"\n or condition.clinicalStatus ~ \"relapse\" then\n Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()]\nelse\n (end of condition.abatementInterval()) abatementDate\n return if abatementDate is null then\n Interval[start of condition.onset.toInterval(), abatementDate)\n else\n Interval[start of condition.onset.toInterval(), abatementDate]" + }, + { + "url": "displaySequence", + "valueInteger": 18 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isProcedurePerformed" + }, + { + "url": "statement", + "valueString": "//Procedure, Performed\ndefine fluent function isProcedurePerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 19 + } + ] + } + ], + "name": "EffectiveDataRequirements", + "status": "active", + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "module-definition" + } + ] + }, + "relatedArtifact": [ + { + "type": "depends-on", + "display": "Library Status", + "resource": { + "reference": "Library/Status|1.8.000" + } + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": { + "reference": "Library/FHIRHelpers|4.4.000" + } + }, + { + "type": "depends-on", + "display": "Library QICoreCommon", + "resource": { + "reference": "Library/QICoreCommon|2.1.000" + } + }, + { + "type": "depends-on", + "display": "Library Hospice", + "resource": { + "reference": "Library/Hospice|6.12.000" + } + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": { + "reference": "Library/PalliativeCare|1.11.000" + } + }, + { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": { + "reference": "http://terminology.hl7.org/CodeSystem/observation-category" + } + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": { + "reference": "http://snomed.info/sct" + } + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": { + "reference": "http://loinc.org" + } + }, + { + "type": "depends-on", + "display": "Value set Pap Test", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" + } + }, + { + "type": "depends-on", + "display": "Value set HPV Test", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" + } + }, + { + "type": "depends-on", + "display": "Value set Office Visit", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Established Office Visit, 18 and Up", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Initial Office Visit, 18 and Up", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + }, + { + "type": "depends-on", + "display": "Value set Home Healthcare Services", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + }, + { + "type": "depends-on", + "display": "Value set Telephone Visits", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + }, + { + "type": "depends-on", + "display": "Value set Virtual Encounter", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + }, + { + "type": "depends-on", + "display": "Value set Encounter Inpatient", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + }, + { + "type": "depends-on", + "display": "Value set Hospice Encounter", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + }, + { + "type": "depends-on", + "display": "Value set Hospice Care Ambulatory", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + }, + { + "type": "depends-on", + "display": "Value set Hospice Diagnosis", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + }, + { + "type": "depends-on", + "display": "Value set Hysterectomy with No Residual Cervix", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + } + }, + { + "type": "depends-on", + "display": "Value set Congenital or Acquired Absence of Cervix", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + } + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Diagnosis", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Encounter", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Intervention", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + } + ], + "dataRequirement": [ + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ], + "valueSetReference": {} + }, + { + "path": "value", + "valueSetReference": {} + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ], + "valueSetReference": {} + } + ] + }, + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + } + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + } + ] + } + ] + } + ], + "extension": [ + { + "id": "effective-data-requirements", + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-effectiveDataRequirements", + "valueReference": { + "reference": "#effective-data-requirements" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + }, + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlOptions", + "valueReference": { + "reference": "Measure/cql-options-test" + } + }, + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expansionParameters", + "valueReference": { + "reference": "#exp-params-test-absent" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-inputParameters", + "valueReference": { + "reference": "Library/input-parameters-test" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-component", + "valueRelatedArtifact": { + "resource": { "reference": "Library/cqfm-component-test" }, + "type": "composed-of" + } + } + ], + "url": "https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR", + "identifier": [ + { + "use": "usual", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "short-name" + } + ] + }, + "system": "https://madie.cms.gov/measure/shortName", + "value": "CMS124FHIR" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-independent" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:3be5df74-24e1-46ed-b899-6e98b9e3760b" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-specific" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:d66e7255-e320-4d80-b28a-091f041ea7e0" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "publisher" + } + ] + }, + "system": "https://madie.cms.gov/measure/cmsId", + "value": "124FHIR", + "assigner": { + "display": "CMS" + } + } + ], + "version": "0.0.001", + "name": "CervicalCancerScreeningFHIR", + "title": "Cervical Cancer ScreeningFHIR", + "status": "active", + "experimental": false, + "date": "2024-07-09T14:53:56+00:00", + "publisher": "National Committee for Quality Assurance", + "contact": [ + { + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "description": "Percentage of women 21-64 years of age who were screened for cervical cancer using either of the following criteria: - Women age 21-64 who had cervical cytology performed within the last 3 years - Women age 30-64 who had cervical human papillomavirus (HPV) testing performed within the last 5 years", + "purpose": "UNKNOWN", + "usage": "To ensure the measure is only looking for a cervical cytology test only after a woman turns 21 years of age, the youngest age in the initial population is 23. Please note the measure may include screenings performed outside the age range of patients referenced in the initial population. Screenings that occur prior to the measurement period are valid to meet measure criteria. Evidence of hrHPV testing within the last 5 years also captures patients who had cotesting; therefore additional methods to identify cotesting are not necessary. This eCQM is a patient-based measure. This FHIR-based measure has been derived from the QDM-based measure: CMS124v13. Please refer to the HL7 QI-Core Implementation Guide (https://hl7.org/fhir/us/qicore/STU4.1.1/) for more information on QI-Core and mapping recommendations from QDM to QI-Core 4.1.1 (https://hl7.org/fhir/us/qicore/STU4.1.1/qdm-to-qicore.html).", + "copyright": "This Physician Performance Measure (Measure) and related data specifications are owned and were developed by the National Committee for Quality Assurance (NCQA). NCQA is not responsible for any use of the Measure. NCQA makes no representations, warranties, or endorsement about the quality of any organization or physician that uses or reports performance measures and NCQA has no liability to anyone who relies on such measures or specifications. NCQA holds a copyright in the Measure. The Measure can be reproduced and distributed, without modification, for noncommercial purposes (e.g., use by healthcare providers in connection with their practices) without obtaining approval from NCQA. Commercial use is defined as the sale, licensing, or distribution of the Measure for commercial gain, or incorporation of the Measure into a product or service that is sold, licensed or distributed for commercial gain. All commercial uses or requests for modification must be approved by NCQA and are subject to a license at the discretion of NCQA. (C) 2012-2021 National Committee for Quality Assurance. All Rights Reserved. Limited proprietary coding is contained in the Measure specifications for user convenience. Users of proprietary code sets should obtain all necessary licenses from the owners of the code sets. NCQA disclaims all liability for use or accuracy of any third party codes contained in the specifications. CPT(R) contained in the Measure specifications is copyright 2004-2021 American Medical Association. LOINC(R) copyright 2004-2021 Regenstrief Institute, Inc. This material contains SNOMED Clinical Terms(R) (SNOMED CT[R]) copyright 2004-2021 International Health Terminology Standards Development Organisation. ICD-10 copyright 2021 World Health Organization. All Rights Reserved.", + "effectivePeriod": { + "start": "2025-01-01", + "end": "2025-12-31" + }, + "author": [ + { + "name": "National Committee for Quality Assurance", + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "library": [ + { + "reference": "https://madie.cms.gov/Library/CervicalCancerScreeningFHIR" + } + ], + "disclaimer": "The performance Measure is not a clinical guideline and does not establish a standard of medical care, and has not been tested for all potential applications. THE MEASURE AND SPECIFICATIONS ARE PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. Due to technical limitations, registered trademarks are indicated by (R) or [R] and unregistered trademarks are indicated by (TM) or [TM].", + "rationale": "All women are at risk for cervical cancer. In 2020, an estimated 13,800 women were diagnosed with cervical cancer in the U.S., resulting in an estimated 4,290 deaths (National Cancer Institute, 2020). Screening can identify precancerous lesions and can detect invasive cancer early, when treatment is more likely to be successful (American Cancer Society, 2020).", + "clinicalRecommendationStatement": "US Preventive Services Task Force (USPSTF) (2018) \"The USPSTF recommends screening for cervical cancer every 3 years with cervical cytology alone in women aged 21 to 29 years. For women aged 30 to 65 years, the USPSTF recommends screening every 3 years with cervical cytology alone, every 5 years with high-risk human papillomavirus (hrHPV) testing alone, or every 5 years with hrHPV testing in combination with cytology (cotesting) (A recommendation)\" \"The USPSTF recommends against screening for cervical cancer in women older than 65 years who have had adequate prior screening and are not otherwise at high risk for cervical cancer. (D recommendation)\" \"The USPSTF recommends against screening for cervical cancer in women younger than 21 years. (D recommendation)\" \"The USPSTF recommends against screening for cervical cancer in women who have had a hysterectomy with removal of the cervix and do not have a history of a high-grade precancerous lesion (ie, cervical intraepithelial neoplasia [CIN] grade 2 or 3) or cervical cancer. (D recommendation)\"", + "group": [ + { + "id": "64d29f68f9c3ae6981ef507d", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-scoring", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-scoring", + "code": "proportion", + "display": "Proportion" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-populationBasis", + "valueCode": "boolean" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-type", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-type", + "code": "process", + "display": "Process" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-rateAggregation", + "valueCode": "None" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-improvementNotation", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-improvement-notation", + "code": "decrease", + "display": "increase" + } + ] + } + } + ], + "population": [ + { + "id": "0CB398EC-F7C3-4882-98FF-D9E0E3E62B4F", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "initial-population", + "display": "Initial Population" + } + ] + }, + "description": "Women 24-64 years of age by the end of the measurement period with a visit during the measurement period", + "criteria": { + "language": "text/cql-identifier", + "expression": "Initial Population" + } + }, + { + "id": "C02AA51E-4436-4034-A67F-DB42C22EB337", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator", + "display": "Denominator" + } + ] + }, + "description": "Equals Initial Population", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator" + } + }, + { + "id": "2EF6ABDF-E416-44B8-928B-DCC7D7C55860", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator-exclusion", + "display": "Denominator Exclusion" + } + ] + }, + "description": "Exclude patients who are in hospice care for any part of the measurement period. Women who had a hysterectomy with no residual cervix or a congenital absence of cervix. Exclude patients receiving palliative care for any part of the measurement period.", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator Exclusions" + } + }, + { + "id": "56088E3D-0DEE-43D2-9866-1F38ACB030CB", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "numerator", + "display": "Numerator" + } + ] + }, + "description": "Women with one or more screenings for cervical cancer. Appropriate screenings are defined by any one of the following criteria: - Cervical cytology performed during the measurement period or the two years prior to the measurement period for women who are at least 21 years old at the time of the test. - Cervical human papillomavirus (HPV) testing performed during the measurement period or the four years prior to the measurement period for women who are 30 years or older at the time of the test.", + "criteria": { + "language": "text/cql-identifier", + "expression": "Numerator" + } + } + ] + } + ] + }, + "request": { + "method": "PUT", + "url": "Measure/CervicalCancerScreeningFHIR" + } + }, + { + "fullUrl": "https://madie.cms.gov/Library/CervicalCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Library", + "id": "CervicalCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-library-cqfm" + ] + }, + "language": "en", + "contained": [ + { + "resourceType": "Parameters", + "id": "options", + "parameter": [ + { + "name": "translatorVersion", + "valueString": "3.10.0" + }, + { + "name": "option", + "valueString": "EnableAnnotations" + }, + { + "name": "option", + "valueString": "EnableLocators" + }, + { + "name": "option", + "valueString": "DisableListDemotion" + }, + { + "name": "option", + "valueString": "DisableListPromotion" + }, + { + "name": "format", + "valueString": "XML" + }, + { + "name": "format", + "valueString": "JSON" + }, + { + "name": "analyzeDataRequirements", + "valueBoolean": true + }, + { + "name": "collapseDataRequirements", + "valueBoolean": true + }, + { + "name": "compatibilityLevel", + "valueString": "1.5" + }, + { + "name": "enableCqlOnly", + "valueBoolean": false + }, + { + "name": "errorLevel", + "valueString": "Info" + }, + { + "name": "signatureLevel", + "valueString": "None" + }, + { + "name": "validateUnits", + "valueBoolean": true + }, + { + "name": "verifyOnly", + "valueBoolean": false + } + ] + } + ], + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlOptions", + "valueReference": { + "reference": "#options" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } + ], + "url": "https://madie.cms.gov/Library/CervicalCancerScreeningFHIR", + "identifier": [ + { + "use": "official", + "system": "https://madie.cms.gov/login", + "value": "CervicalCancerScreeningFHIR" + } + ], + "version": "0.0.001", + "name": "CervicalCancerScreeningFHIR", + "title": "CervicalCancerScreeningFHIR", + "status": "active", + "experimental": false, + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } + ] + }, + "date": "2024-05-16T13:50:20+00:00", + "description": "CervicalCancerScreeningFHIR", + "relatedArtifact": [ + { + "type": "depends-on", + "display": "QICore model information", + "resource": { + "reference": "http://hl7.org/fhir/Library/QICore-ModelInfo" + } + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": { + "reference": "http://ecqi.healthit.gov/ecqms/Library/FHIRHelpers|4.4.000" + } + }, + { + "type": "depends-on", + "display": "Library Hospice", + "resource": { + "reference": "http://ecqi.healthit.gov/ecqms/Library/Hospice|6.12.000" + } + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": { + "reference": "http://ecqi.healthit.gov/ecqms/Library/PalliativeCare|1.11.000" + } + }, + { + "type": "depends-on", + "display": "Library Status", + "resource": { + "reference": "http://ecqi.healthit.gov/ecqms/Library/Status|1.8.000" + } + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": { + "reference": "http://snomed.info/sct" + } + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": { + "reference": "http://loinc.org" + } + }, + { + "type": "depends-on", + "display": "Code system AdministrativeGender", + "resource": { + "reference": "http://hl7.org/fhir/administrative-gender" + } + }, + { + "type": "depends-on", + "display": "Value set Congenital or Acquired Absence of Cervix", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + } + }, + { + "type": "depends-on", + "display": "Value set Hysterectomy with No Residual Cervix", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + } + }, + { + "type": "depends-on", + "display": "Value set Encounter Inpatient", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Diagnosis", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + }, + { + "type": "depends-on", + "display": "Value set Payer Type", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "Qualifying Encounters", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Absence of Cervix", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Cervical Cytology Within 3 Years", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "HPV Test Within 5 Years for Women Age 30 and Older", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "SDE Ethnicity", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Payer", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "SDE Race", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Sex", + "use": "out", + "min": 0, + "max": "1", + "type": "Coding" + } + ], + "dataRequirement": [ + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ], + "mustSupport": ["ethnicity", "race"] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + } + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ], + "valueSetReference": {} + }, + { + "path": "value", + "valueSetReference": {} + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ], + "valueSetReference": {} + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" + } + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + } + ] + }, + { + "type": "Coverage", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-coverage" + ], + "mustSupport": ["type", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + } + ] + } + ], + "content": [ + { + "contentType": "text/cql", + "data": "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" + }, + { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1" localId="0">
   <annotation translatorVersion="3.10.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" signatureLevel="None" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:s r="587">
         <a:s>library CervicalCancerScreeningFHIR version '0.0.001'</a:s>
      </a:s>
   </annotation>
   <identifier id="CervicalCancerScreeningFHIR" system="http://ecqi.healthit.gov/ecqms" version="0.0.001"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localId="1" localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="206" locator="3:1-3:28" localIdentifier="QICore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="206">
               <a:s>using </a:s>
               <a:s>
                  <a:s>QICore</a:s>
               </a:s>
               <a:s> version '4.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="207" locator="5:1-5:56" localIdentifier="FHIRHelpers" path="http://ecqi.healthit.gov/ecqms/FHIRHelpers" version="4.4.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="207">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.4.000' called FHIRHelpers</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="208" locator="6:1-6:61" localIdentifier="SDE" path="http://ecqi.healthit.gov/ecqms/SupplementalDataElements" version="3.5.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="208">
               <a:s>include </a:s>
               <a:s>
                  <a:s>SupplementalDataElements</a:s>
               </a:s>
               <a:s> version '3.5.000' called SDE</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="209" locator="7:1-7:58" localIdentifier="QICoreCommon" path="http://ecqi.healthit.gov/ecqms/QICoreCommon" version="2.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="209">
               <a:s>include </a:s>
               <a:s>
                  <a:s>QICoreCommon</a:s>
               </a:s>
               <a:s> version '2.1.000' called QICoreCommon</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="210" locator="8:1-8:49" localIdentifier="Hospice" path="http://ecqi.healthit.gov/ecqms/Hospice" version="6.12.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="210">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Hospice</a:s>
               </a:s>
               <a:s> version '6.12.000' called Hospice</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="211" locator="9:1-9:63" localIdentifier="PalliativeCare" path="http://ecqi.healthit.gov/ecqms/PalliativeCare" version="1.11.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="211">
               <a:s>include </a:s>
               <a:s>
                  <a:s>PalliativeCare</a:s>
               </a:s>
               <a:s> version '1.11.000' called PalliativeCare</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="212" locator="10:1-10:46" localIdentifier="Status" path="http://ecqi.healthit.gov/ecqms/Status" version="1.8.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="212">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Status</a:s>
               </a:s>
               <a:s> version '1.8.000' called Status</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <parameters>
      <def localId="223" locator="23:1-23:49" name="Measurement Period" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="223">
               <a:s>parameter &quot;Measurement Period&quot; </a:s>
               <a:s r="224">
                  <a:s>Interval&lt;</a:s>
                  <a:s r="225">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
            </a:s>
         </annotation>
         <parameterTypeSpecifier localId="224" locator="23:32-23:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="225" locator="23:41-23:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <valueSets>
      <def localId="213" locator="12:1-12:132" name="Congenital or Acquired Absence of Cervix" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="213">
               <a:s>valueset &quot;Congenital or Acquired Absence of Cervix&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="214" locator="13:1-13:116" name="Home Healthcare Services" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="214">
               <a:s>valueset &quot;Home Healthcare Services&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="215" locator="14:1-14:100" name="HPV Test" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="215">
               <a:s>valueset &quot;HPV Test&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="216" locator="15:1-15:128" name="Hysterectomy with No Residual Cervix" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="216">
               <a:s>valueset &quot;Hysterectomy with No Residual Cervix&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="217" locator="16:1-16:104" name="Office Visit" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="217">
               <a:s>valueset &quot;Office Visit&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="218" locator="17:1-17:109" name="Virtual Encounter" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="218">
               <a:s>valueset &quot;Virtual Encounter&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="219" locator="18:1-18:100" name="Pap Test" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="219">
               <a:s>valueset &quot;Pap Test&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="220" locator="19:1-19:152" name="Preventive Care Services Established Office Visit, 18 and Up" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="220">
               <a:s>valueset &quot;Preventive Care Services Established Office Visit, 18 and Up&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="221" locator="20:1-20:148" name="Preventive Care Services Initial Office Visit, 18 and Up" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="221">
               <a:s>valueset &quot;Preventive Care Services Initial Office Visit, 18 and Up&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="222" locator="21:1-21:108" name="Telephone Visits" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="222">
               <a:s>valueset &quot;Telephone Visits&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080'</a:s>
            </a:s>
         </annotation>
      </def>
   </valueSets>
   <contexts>
      <def localId="229" locator="25:1-25:15" name="Patient"/>
   </contexts>
   <statements>
      <def localId="227" locator="25:1-25:15" name="Patient" context="Patient">
         <expression localId="228" xsi:type="SingletonFrom">
            <operand localId="226" locator="25:1-25:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="254" locator="34:1-42:82" name="Qualifying Encounters" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="254">
               <a:s>define &quot;Qualifying Encounters&quot;:
  </a:s>
               <a:s r="304">
                  <a:s>
                     <a:s r="255">
                        <a:s r="287">
                           <a:s>( </a:s>
                           <a:s r="287">
                              <a:s r="286">
                                 <a:s>( </a:s>
                                 <a:s r="286">
                                    <a:s r="280">
                                       <a:s r="275">
                                          <a:s r="269">
                                             <a:s r="264">
                                                <a:s r="258">
                                                   <a:s>[&quot;Encounter&quot;: </a:s>
                                                   <a:s>
                                                      <a:s>&quot;Office Visit&quot;</a:s>
                                                   </a:s>
                                                   <a:s>]</a:s>
                                                </a:s>
                                                <a:s>
      union </a:s>
                                                <a:s r="262">
                                                   <a:s>[Encounter: </a:s>
                                                   <a:s>
                                                      <a:s>&quot;Preventive Care Services Established Office Visit, 18 and Up&quot;</a:s>
                                                   </a:s>
                                                   <a:s>]</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
      union </a:s>
                                             <a:s r="267">
                                                <a:s>[Encounter: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Preventive Care Services Initial Office Visit, 18 and Up&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
      union </a:s>
                                          <a:s r="272">
                                             <a:s>[Encounter: </a:s>
                                             <a:s>
                                                <a:s>&quot;Home Healthcare Services&quot;</a:s>
                                             </a:s>
                                             <a:s>]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>
      union </a:s>
                                       <a:s r="278">
                                          <a:s>[Encounter: </a:s>
                                          <a:s>
                                             <a:s>&quot;Telephone Visits&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
      union </a:s>
                                    <a:s r="283">
                                       <a:s>[Encounter: </a:s>
                                       <a:s>
                                          <a:s>&quot;Virtual Encounter&quot;</a:s>
                                       </a:s>
                                       <a:s>]</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
  )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="287">
                                 <a:s>isEncounterPerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> ValidEncounters</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="302">
                     <a:s>where </a:s>
                     <a:s r="302">
                        <a:s r="291">
                           <a:s r="290">
                              <a:s r="288">
                                 <a:s>ValidEncounters</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="290">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="291">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="302"> during day of </a:s>
                        <a:s r="301">
                           <a:s>&quot;Measurement Period&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="304" locator="35:3-42:82" xsi:type="Query">
            <source localId="255" locator="35:3-41:46" alias="ValidEncounters">
               <expression localId="287" locator="35:3-41:30" name="isEncounterPerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="286" locator="35:5-41:3" xsi:type="Union">
                     <operand localId="275" locator="35:7-38:51" xsi:type="Union">
                        <operand localId="264" locator="35:7-36:87" xsi:type="Union">
                           <operand localId="258" locator="35:7-35:35" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="257" locator="35:21-35:34" name="Office Visit" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                           <operand localId="262" locator="36:13-36:87" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="261" locator="36:25-36:86" name="Preventive Care Services Established Office Visit, 18 and Up" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                        </operand>
                        <operand localId="274" xsi:type="Union">
                           <operand localId="267" locator="37:13-37:83" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="266" locator="37:25-37:82" name="Preventive Care Services Initial Office Visit, 18 and Up" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                           <operand localId="272" locator="38:13-38:51" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="271" locator="38:25-38:50" name="Home Healthcare Services" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="285" xsi:type="Union">
                        <operand localId="278" locator="39:13-39:43" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="277" locator="39:25-39:42" name="Telephone Visits" preserve="true" xsi:type="ValueSetRef"/>
                        </operand>
                        <operand localId="283" locator="40:13-40:44" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="282" locator="40:25-40:43" name="Virtual Encounter" preserve="true" xsi:type="ValueSetRef"/>
                        </operand>
                     </operand>
                  </operand>
               </expression>
            </source>
            <where localId="302" locator="42:5-42:82" precision="Day" xsi:type="IncludedIn">
               <operand localId="291" locator="42:11-42:47" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                  <operand localId="292" xsi:type="As">
                     <operand localId="290" locator="42:11-42:32" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="289" path="period" scope="ValidEncounters" xsi:type="Property"/>
                     </operand>
                     <asTypeSpecifier localId="293" xsi:type="ChoiceTypeSpecifier">
                        <choice localId="294" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                        <choice localId="295" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        <choice localId="296" xsi:type="IntervalTypeSpecifier">
                           <pointType localId="297" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                        </choice>
                        <choice localId="298" xsi:type="IntervalTypeSpecifier">
                           <pointType localId="299" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        </choice>
                        <choice localId="300" name="fhir:Timing" xsi:type="NamedTypeSpecifier"/>
                     </asTypeSpecifier>
                  </operand>
               </operand>
               <operand localId="301" locator="42:63-42:82" name="Measurement Period" xsi:type="ParameterRef"/>
            </where>
         </expression>
      </def>
      <def localId="231" locator="27:1-32:38" name="Initial Population" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="231">
               <a:s>define &quot;Initial Population&quot;:
  </a:s>
               <a:s r="232">
                  <a:s r="233">
                     <a:s r="246">
                        <a:s r="242">
                           <a:s>AgeInYearsAt(</a:s>
                           <a:s r="234">
                              <a:s>date from 
    </a:s>
                              <a:s r="235">
                                 <a:s>end of </a:s>
                                 <a:s r="236">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
  )</a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="245">
                           <a:s r="243">Interval[24, 64]</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    and </a:s>
                     <a:s r="247">
                        <a:s r="250">
                           <a:s r="248">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="250">
                              <a:s>gender</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="251">
                           <a:s>'female'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    and </a:s>
                  <a:s r="252">
                     <a:s>exists </a:s>
                     <a:s r="305">
                        <a:s>&quot;Qualifying Encounters&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="232" locator="28:3-32:38" xsi:type="And">
            <operand localId="233" locator="28:3-31:33" xsi:type="And">
               <operand localId="246" locator="28:3-30:23" xsi:type="In">
                  <operand localId="242" locator="28:3-30:3" precision="Year" xsi:type="CalculateAgeAt">
                     <operand localId="241" path="value" xsi:type="Property">
                        <source localId="240" path="birthDate" xsi:type="Property">
                           <source localId="239" name="Patient" xsi:type="ExpressionRef"/>
                        </source>
                     </operand>
                     <operand localId="234" locator="28:16-29:31" xsi:type="DateFrom">
                        <operand localId="235" locator="29:5-29:31" xsi:type="End">
                           <operand localId="236" locator="29:12-29:31" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="245" locator="30:8-30:23" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="243" locator="30:17-30:18" valueType="t:Integer" value="24" xsi:type="Literal"/>
                     <high localId="244" locator="30:21-30:22" valueType="t:Integer" value="64" xsi:type="Literal"/>
                  </operand>
               </operand>
               <operand localId="247" locator="31:9-31:33" xsi:type="Equal">
                  <operand localId="250" locator="31:9-31:22" path="value" xsi:type="Property">
                     <source localId="249" path="gender" xsi:type="Property">
                        <source localId="248" locator="31:9-31:15" name="Patient" xsi:type="ExpressionRef"/>
                     </source>
                  </operand>
                  <operand localId="251" locator="31:26-31:33" valueType="t:String" value="female" xsi:type="Literal"/>
               </operand>
            </operand>
            <operand localId="252" locator="32:9-32:38" xsi:type="Exists">
               <operand localId="305" locator="32:16-32:38" name="Qualifying Encounters" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="307" locator="44:1-45:22" name="Denominator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="307">
               <a:s>define &quot;Denominator&quot;:
  </a:s>
               <a:s r="308">
                  <a:s>&quot;Initial Population&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="308" locator="45:3-45:22" name="Initial Population" xsi:type="ExpressionRef"/>
      </def>
      <def localId="317" locator="56:1-62:5" name="Absence of Cervix" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="317">
               <a:s>define &quot;Absence of Cervix&quot;:
  </a:s>
               <a:s r="355">
                  <a:s r="332">
                     <a:s>( </a:s>
                     <a:s r="332">
                        <a:s>
                           <a:s r="318">
                              <a:s r="323">
                                 <a:s>( </a:s>
                                 <a:s r="323">
                                    <a:s r="321">
                                       <a:s>( </a:s>
                                       <a:s r="321">
                                          <a:s>[Procedure: </a:s>
                                          <a:s>
                                             <a:s>&quot;Hysterectomy with No Residual Cervix&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                       <a:s> )</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="323">
                                       <a:s>isProcedurePerformed ( )</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s> NoCervixProcedure</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="331">
                           <a:s>where </a:s>
                           <a:s r="331">
                              <a:s r="327">
                                 <a:s r="326">
                                    <a:s r="324">
                                       <a:s>NoCervixProcedure</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="326">
                                       <a:s>performed</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="327">
                                    <a:s>toInterval ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="331"> ends on or before </a:s>
                              <a:s r="328">
                                 <a:s>end of </a:s>
                                 <a:s r="329">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
                  <a:s>
    union </a:s>
                  <a:s r="344">
                     <a:s>( </a:s>
                     <a:s r="344">
                        <a:s>
                           <a:s r="333">
                              <a:s r="336">
                                 <a:s r="336">
                                    <a:s>[Condition: </a:s>
                                    <a:s>
                                       <a:s>&quot;Congenital or Acquired Absence of Cervix&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> NoCervixDiagnosis</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
        </a:s>
                        <a:s r="343">
                           <a:s>where </a:s>
                           <a:s r="343">
                              <a:s r="339">
                                 <a:s r="338">
                                    <a:s>NoCervixDiagnosis</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="339">
                                    <a:s>prevalenceInterval ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="343"> starts on or before </a:s>
                              <a:s r="340">
                                 <a:s>end of </a:s>
                                 <a:s r="341">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="355" locator="57:3-62:5" xsi:type="Union">
            <operand localId="345" xsi:type="As">
               <operand localId="332" locator="57:3-59:3" xsi:type="Query">
                  <source localId="318" locator="57:5-57:106" alias="NoCervixProcedure">
                     <expression localId="323" locator="57:5-57:88" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                        <operand localId="321" locator="57:7-57:61" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="320" locator="57:21-57:58" name="Hysterectomy with No Residual Cervix" preserve="true" xsi:type="ValueSetRef"/>
                        </operand>
                     </expression>
                  </source>
                  <where localId="331" locator="58:7-58:100" xsi:type="SameOrBefore">
                     <operand localId="330" locator="58:56-58:59" xsi:type="End">
                        <operand localId="327" locator="58:13-58:54" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                           <operand localId="326" locator="58:13-58:39" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="325" path="performed" scope="NoCervixProcedure" xsi:type="Property"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="328" locator="58:74-58:100" xsi:type="End">
                        <operand localId="329" locator="58:81-58:100" name="Measurement Period" xsi:type="ParameterRef"/>
                     </operand>
                  </where>
               </operand>
               <asTypeSpecifier localId="346" xsi:type="ListTypeSpecifier">
                  <elementType localId="347" xsi:type="ChoiceTypeSpecifier">
                     <choice localId="348" name="fhir:Procedure" xsi:type="NamedTypeSpecifier"/>
                     <choice localId="349" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
                  </elementType>
               </asTypeSpecifier>
            </operand>
            <operand localId="350" xsi:type="As">
               <operand localId="344" locator="60:11-62:5" xsi:type="Query">
                  <source localId="333" locator="60:13-60:85" alias="NoCervixDiagnosis">
                     <expression localId="336" locator="60:13-60:67" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                        <codes localId="335" locator="60:25-60:66" name="Congenital or Acquired Absence of Cervix" preserve="true" xsi:type="ValueSetRef"/>
                     </expression>
                  </source>
                  <where localId="343" locator="61:9-61:102" xsi:type="SameOrBefore">
                     <operand localId="342" locator="61:56-61:61" xsi:type="Start">
                        <operand localId="339" locator="61:15-61:54" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                           <operand localId="338" locator="61:15-61:31" name="NoCervixDiagnosis" xsi:type="AliasRef"/>
                        </operand>
                     </operand>
                     <operand localId="340" locator="61:76-61:102" xsi:type="End">
                        <operand localId="341" locator="61:83-61:102" name="Measurement Period" xsi:type="ParameterRef"/>
                     </operand>
                  </where>
               </operand>
               <asTypeSpecifier localId="351" xsi:type="ListTypeSpecifier">
                  <elementType localId="352" xsi:type="ChoiceTypeSpecifier">
                     <choice localId="353" name="fhir:Procedure" xsi:type="NamedTypeSpecifier"/>
                     <choice localId="354" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
                  </elementType>
               </asTypeSpecifier>
            </operand>
         </expression>
      </def>
      <def localId="310" locator="47:1-50:69" name="Denominator Exclusions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="310">
               <a:s>define &quot;Denominator Exclusions&quot;:
  </a:s>
               <a:s r="311">
                  <a:s r="312">
                     <a:s r="314">
                        <a:s r="313">
                           <a:s>Hospice</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="314">
                           <a:s>&quot;Has Hospice Services&quot;</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="315">
                        <a:s>exists </a:s>
                        <a:s r="356">
                           <a:s>&quot;Absence of Cervix&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    or </a:s>
                  <a:s r="358">
                     <a:s r="357">
                        <a:s>PalliativeCare</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="358">
                        <a:s>&quot;Has Palliative Care in the Measurement Period&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="311" locator="48:3-50:69" xsi:type="Or">
            <operand localId="312" locator="48:3-49:33" xsi:type="Or">
               <operand localId="314" locator="48:3-48:32" name="Has Hospice Services" libraryName="Hospice" xsi:type="ExpressionRef"/>
               <operand localId="315" locator="49:8-49:33" xsi:type="Exists">
                  <operand localId="356" locator="49:15-49:33" name="Absence of Cervix" xsi:type="ExpressionRef"/>
               </operand>
            </operand>
            <operand localId="358" locator="50:8-50:69" name="Has Palliative Care in the Measurement Period" libraryName="PalliativeCare" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="364" locator="64:1-67:44" name="Cervical Cytology Within 3 Years" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="364">
               <a:s>define &quot;Cervical Cytology Within 3 Years&quot;:
  </a:s>
               <a:s r="436">
                  <a:s>
                     <a:s r="365">
                        <a:s r="370">
                           <a:s>( </a:s>
                           <a:s r="370">
                              <a:s r="368">
                                 <a:s>( </a:s>
                                 <a:s r="368">
                                    <a:s>[Observation: </a:s>
                                    <a:s>
                                       <a:s>&quot;Pap Test&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="370">
                                 <a:s>isLaboratoryTestPerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> CervicalCytology</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="371">
                     <a:s>where </a:s>
                     <a:s r="371">
                        <a:s r="430">
                           <a:s r="375">
                              <a:s r="374">
                                 <a:s r="372">
                                    <a:s>CervicalCytology</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="374">
                                    <a:s>effective</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="375">
                                 <a:s>latest ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="430"> during day of </a:s>
                           <a:s r="428">
                              <a:s>Interval[</a:s>
                              <a:s r="422">
                                 <a:s r="423">
                                    <a:s>start of </a:s>
                                    <a:s r="424">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> - </a:s>
                                 <a:s r="425">
                                    <a:s>2 years</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="426">
                                 <a:s>end of </a:s>
                                 <a:s r="427">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="435">
                           <a:s r="433">
                              <a:s r="431">
                                 <a:s>CervicalCytology</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="433">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s> is not null</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="436" locator="65:3-67:44" xsi:type="Query">
            <source localId="365" locator="65:3-65:82" alias="CervicalCytology">
               <expression localId="370" locator="65:3-65:65" name="isLaboratoryTestPerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="368" locator="65:5-65:33" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="367" locator="65:21-65:30" name="Pap Test" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="371" locator="66:5-67:44" xsi:type="And">
               <operand localId="430" locator="66:11-66:140" precision="Day" xsi:type="In">
                  <operand localId="375" locator="66:11-66:47" name="latest" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="385" xsi:type="Case">
                        <caseItem localId="386">
                           <when localId="387" isType="t:DateTime" xsi:type="Is">
                              <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                              </operand>
                           </when>
                           <then localId="377" xsi:type="As">
                              <operand localId="376" asType="t:DateTime" xsi:type="As">
                                 <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                                 </operand>
                              </operand>
                              <asTypeSpecifier localId="378" xsi:type="ChoiceTypeSpecifier">
                                 <choice localId="379" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="380" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="381" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="382" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice localId="383" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="384" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <caseItem localId="388">
                           <when localId="389" xsi:type="Is">
                              <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                              </operand>
                              <isTypeSpecifier localId="390" xsi:type="IntervalTypeSpecifier">
                                 <pointType localId="391" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </isTypeSpecifier>
                           </when>
                           <then localId="395" xsi:type="As">
                              <operand localId="392" xsi:type="As">
                                 <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                                 </operand>
                                 <asTypeSpecifier localId="393" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="394" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </asTypeSpecifier>
                              </operand>
                              <asTypeSpecifier localId="396" xsi:type="ChoiceTypeSpecifier">
                                 <choice localId="397" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="398" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="399" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="400" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice localId="401" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="402" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <caseItem localId="403">
                           <when localId="404" isType="t:DateTime" xsi:type="Is">
                              <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                              </operand>
                           </when>
                           <then localId="406" xsi:type="As">
                              <operand localId="405" asType="t:DateTime" xsi:type="As">
                                 <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                                 </operand>
                              </operand>
                              <asTypeSpecifier localId="407" xsi:type="ChoiceTypeSpecifier">
                                 <choice localId="408" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="409" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="410" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="411" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice localId="412" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="413" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <else localId="414" xsi:type="Null"/>
                     </operand>
                  </operand>
                  <operand localId="428" locator="66:63-66:140" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="422" locator="66:72-66:110" xsi:type="Subtract">
                        <operand localId="423" locator="66:72-66:100" xsi:type="Start">
                           <operand localId="424" locator="66:81-66:100" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                        <operand localId="425" locator="66:104-66:110" value="2" unit="years" xsi:type="Quantity"/>
                     </low>
                     <high localId="426" locator="66:113-66:139" xsi:type="End">
                        <operand localId="427" locator="66:120-66:139" name="Measurement Period" xsi:type="ParameterRef"/>
                     </high>
                  </operand>
               </operand>
               <operand localId="435" locator="67:11-67:44" xsi:type="Not">
                  <operand localId="434" locator="67:11-67:44" xsi:type="IsNull">
                     <operand localId="433" locator="67:11-67:32" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="432" path="value" scope="CervicalCytology" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="440" locator="69:1-73:35" name="HPV Test Within 5 Years for Women Age 30 and Older" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="440">
               <a:s>define &quot;HPV Test Within 5 Years for Women Age 30 and Older&quot;:
  </a:s>
               <a:s r="572">
                  <a:s>
                     <a:s r="441">
                        <a:s r="446">
                           <a:s>( </a:s>
                           <a:s r="446">
                              <a:s r="444">
                                 <a:s>( </a:s>
                                 <a:s r="444">
                                    <a:s>[Observation: </a:s>
                                    <a:s>
                                       <a:s>&quot;HPV Test&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="446">
                                 <a:s>isLaboratoryTestPerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> HPVTest</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="447">
                     <a:s>where </a:s>
                     <a:s r="447">
                        <a:s r="448">
                           <a:s r="449">
                              <a:s r="506">
                                 <a:s>AgeInYearsAt(</a:s>
                                 <a:s r="450">
                                    <a:s>date from </a:s>
                                    <a:s r="454">
                                       <a:s r="453">
                                          <a:s r="451">
                                             <a:s>HPVTest</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="453">
                                             <a:s>effective</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="454">
                                          <a:s>latest()</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s r="507"> >= 30</a:s>
                           </a:s>
                           <a:s>
      and </a:s>
                           <a:s r="566">
                              <a:s r="511">
                                 <a:s r="510">
                                    <a:s r="508">
                                       <a:s>HPVTest</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="510">
                                       <a:s>effective</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="511">
                                    <a:s>latest ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="566"> during day of </a:s>
                              <a:s r="564">
                                 <a:s>Interval[</a:s>
                                 <a:s r="558">
                                    <a:s r="559">
                                       <a:s>start of </a:s>
                                       <a:s r="560">
                                          <a:s>&quot;Measurement Period&quot;</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> - </a:s>
                                    <a:s r="561">
                                       <a:s>4 years</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="562">
                                    <a:s>end of </a:s>
                                    <a:s r="563">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="571">
                           <a:s r="569">
                              <a:s r="567">
                                 <a:s>HPVTest</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="569">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s> is not null</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="572" locator="70:3-73:35" xsi:type="Query">
            <source localId="441" locator="70:3-70:73" alias="HPVTest">
               <expression localId="446" locator="70:3-70:65" name="isLaboratoryTestPerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="444" locator="70:5-70:33" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="443" locator="70:21-70:30" name="HPV Test" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="447" locator="71:5-73:35" xsi:type="And">
               <operand localId="448" locator="71:11-72:131" xsi:type="And">
                  <operand localId="449" locator="71:11-71:66" xsi:type="GreaterOrEqual">
                     <operand localId="506" locator="71:11-71:60" precision="Year" xsi:type="CalculateAgeAt">
                        <operand localId="505" path="value" xsi:type="Property">
                           <source localId="504" path="birthDate" xsi:type="Property">
                              <source localId="503" name="Patient" xsi:type="ExpressionRef"/>
                           </source>
                        </operand>
                        <operand localId="450" locator="71:24-71:59" xsi:type="DateFrom">
                           <operand localId="454" locator="71:34-71:59" name="latest" libraryName="QICoreCommon" xsi:type="FunctionRef">
                              <operand localId="464" xsi:type="Case">
                                 <caseItem localId="465">
                                    <when localId="466" isType="t:DateTime" xsi:type="Is">
                                       <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                       </operand>
                                    </when>
                                    <then localId="456" xsi:type="As">
                                       <operand localId="455" asType="t:DateTime" xsi:type="As">
                                          <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="457" xsi:type="ChoiceTypeSpecifier">
                                          <choice localId="458" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="459" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="460" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="461" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                          <choice localId="462" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="463" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                       </asTypeSpecifier>
                                    </then>
                                 </caseItem>
                                 <caseItem localId="467">
                                    <when localId="468" xsi:type="Is">
                                       <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                       </operand>
                                       <isTypeSpecifier localId="469" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="470" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </isTypeSpecifier>
                                    </when>
                                    <then localId="474" xsi:type="As">
                                       <operand localId="471" xsi:type="As">
                                          <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                          </operand>
                                          <asTypeSpecifier localId="472" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="473" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </asTypeSpecifier>
                                       </operand>
                                       <asTypeSpecifier localId="475" xsi:type="ChoiceTypeSpecifier">
                                          <choice localId="476" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="477" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="478" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="479" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                          <choice localId="480" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="481" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                       </asTypeSpecifier>
                                    </then>
                                 </caseItem>
                                 <caseItem localId="482">
                                    <when localId="483" isType="t:DateTime" xsi:type="Is">
                                       <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                       </operand>
                                    </when>
                                    <then localId="485" xsi:type="As">
                                       <operand localId="484" asType="t:DateTime" xsi:type="As">
                                          <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="486" xsi:type="ChoiceTypeSpecifier">
                                          <choice localId="487" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="488" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="489" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="490" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                          <choice localId="491" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="492" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                       </asTypeSpecifier>
                                    </then>
                                 </caseItem>
                                 <else localId="493" xsi:type="Null"/>
                              </operand>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="507" locator="71:65-71:66" valueType="t:Integer" value="30" xsi:type="Literal"/>
                  </operand>
                  <operand localId="566" locator="72:11-72:131" precision="Day" xsi:type="In">
                     <operand localId="511" locator="72:11-72:38" name="latest" libraryName="QICoreCommon" xsi:type="FunctionRef">
                        <operand localId="521" xsi:type="Case">
                           <caseItem localId="522">
                              <when localId="523" isType="t:DateTime" xsi:type="Is">
                                 <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                 </operand>
                              </when>
                              <then localId="513" xsi:type="As">
                                 <operand localId="512" asType="t:DateTime" xsi:type="As">
                                    <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                    </operand>
                                 </operand>
                                 <asTypeSpecifier localId="514" xsi:type="ChoiceTypeSpecifier">
                                    <choice localId="515" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="516" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="517" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="518" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                    <choice localId="519" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="520" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                 </asTypeSpecifier>
                              </then>
                           </caseItem>
                           <caseItem localId="524">
                              <when localId="525" xsi:type="Is">
                                 <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                 </operand>
                                 <isTypeSpecifier localId="526" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="527" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </isTypeSpecifier>
                              </when>
                              <then localId="531" xsi:type="As">
                                 <operand localId="528" xsi:type="As">
                                    <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                    </operand>
                                    <asTypeSpecifier localId="529" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="530" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </operand>
                                 <asTypeSpecifier localId="532" xsi:type="ChoiceTypeSpecifier">
                                    <choice localId="533" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="534" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="535" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="536" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                    <choice localId="537" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="538" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                 </asTypeSpecifier>
                              </then>
                           </caseItem>
                           <caseItem localId="539">
                              <when localId="540" isType="t:DateTime" xsi:type="Is">
                                 <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                 </operand>
                              </when>
                              <then localId="542" xsi:type="As">
                                 <operand localId="541" asType="t:DateTime" xsi:type="As">
                                    <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                    </operand>
                                 </operand>
                                 <asTypeSpecifier localId="543" xsi:type="ChoiceTypeSpecifier">
                                    <choice localId="544" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="545" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="546" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="547" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                    <choice localId="548" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="549" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                 </asTypeSpecifier>
                              </then>
                           </caseItem>
                           <else localId="550" xsi:type="Null"/>
                        </operand>
                     </operand>
                     <operand localId="564" locator="72:54-72:131" lowClosed="true" highClosed="true" xsi:type="Interval">
                        <low localId="558" locator="72:63-72:101" xsi:type="Subtract">
                           <operand localId="559" locator="72:63-72:91" xsi:type="Start">
                              <operand localId="560" locator="72:72-72:91" name="Measurement Period" xsi:type="ParameterRef"/>
                           </operand>
                           <operand localId="561" locator="72:95-72:101" value="4" unit="years" xsi:type="Quantity"/>
                        </low>
                        <high localId="562" locator="72:104-72:130" xsi:type="End">
                           <operand localId="563" locator="72:111-72:130" name="Measurement Period" xsi:type="ParameterRef"/>
                        </high>
                     </operand>
                  </operand>
               </operand>
               <operand localId="571" locator="73:11-73:35" xsi:type="Not">
                  <operand localId="570" locator="73:11-73:35" xsi:type="IsNull">
                     <operand localId="569" locator="73:11-73:23" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="568" path="value" scope="HPVTest" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="360" locator="52:1-54:66" name="Numerator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="360">
               <a:s>define &quot;Numerator&quot;:
  </a:s>
               <a:s r="361">
                  <a:s r="362">
                     <a:s>exists </a:s>
                     <a:s r="437">
                        <a:s>&quot;Cervical Cytology Within 3 Years&quot;</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    or </a:s>
                  <a:s r="438">
                     <a:s>exists </a:s>
                     <a:s r="573">
                        <a:s>&quot;HPV Test Within 5 Years for Women Age 30 and Older&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="361" locator="53:3-54:66" xsi:type="Or">
            <operand localId="362" locator="53:3-53:43" xsi:type="Exists">
               <operand localId="437" locator="53:10-53:43" name="Cervical Cytology Within 3 Years" xsi:type="ExpressionRef"/>
            </operand>
            <operand localId="438" locator="54:8-54:66" xsi:type="Exists">
               <operand localId="573" locator="54:15-54:66" name="HPV Test Within 5 Years for Women Age 30 and Older" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="575" locator="75:1-76:21" name="SDE Ethnicity" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="575">
               <a:s>define &quot;SDE Ethnicity&quot;:
  </a:s>
               <a:s r="577">
                  <a:s r="576">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="577">
                     <a:s>&quot;SDE Ethnicity&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="577" locator="76:3-76:21" name="SDE Ethnicity" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="579" locator="78:1-79:17" name="SDE Payer" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="579">
               <a:s>define &quot;SDE Payer&quot;:
  </a:s>
               <a:s r="581">
                  <a:s r="580">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="581">
                     <a:s>&quot;SDE Payer&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="581" locator="79:3-79:17" name="SDE Payer" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="583" locator="81:1-82:16" name="SDE Race" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="583">
               <a:s>define &quot;SDE Race&quot;:
  </a:s>
               <a:s r="585">
                  <a:s r="584">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="585">
                     <a:s>&quot;SDE Race&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="585" locator="82:3-82:16" name="SDE Race" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="587" locator="84:1-85:15" name="SDE Sex" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="587">
               <a:s>define &quot;SDE Sex&quot;:
  </a:s>
               <a:s r="589">
                  <a:s r="588">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="589">
                     <a:s>&quot;SDE Sex&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="589" locator="85:3-85:15" name="SDE Sex" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
   </statements>
</library>
" + }, + { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "localId" : "0",
      "annotation" : [ {
         "translatorVersion" : "3.10.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "signatureLevel" : "None",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "s" : {
            "r" : "587",
            "s" : [ {
               "value" : [ "","library CervicalCancerScreeningFHIR version '0.0.001'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "CervicalCancerScreeningFHIR",
         "system" : "http://ecqi.healthit.gov/ecqms",
         "version" : "0.0.001"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localId" : "1",
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "206",
            "locator" : "3:1-3:28",
            "localIdentifier" : "QICore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "206",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICore" ]
                     } ]
                  }, {
                     "value" : [ " version '4.1.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "207",
            "locator" : "5:1-5:56",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://ecqi.healthit.gov/ecqms/FHIRHelpers",
            "version" : "4.4.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "207",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.4.000'"," called ","FHIRHelpers" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "208",
            "locator" : "6:1-6:61",
            "localIdentifier" : "SDE",
            "path" : "http://ecqi.healthit.gov/ecqms/SupplementalDataElements",
            "version" : "3.5.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "208",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "SupplementalDataElements" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.5.000'"," called ","SDE" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "209",
            "locator" : "7:1-7:58",
            "localIdentifier" : "QICoreCommon",
            "path" : "http://ecqi.healthit.gov/ecqms/QICoreCommon",
            "version" : "2.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "209",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'2.1.000'"," called ","QICoreCommon" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "210",
            "locator" : "8:1-8:49",
            "localIdentifier" : "Hospice",
            "path" : "http://ecqi.healthit.gov/ecqms/Hospice",
            "version" : "6.12.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "210",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Hospice" ]
                     } ]
                  }, {
                     "value" : [ " version ","'6.12.000'"," called ","Hospice" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "211",
            "locator" : "9:1-9:63",
            "localIdentifier" : "PalliativeCare",
            "path" : "http://ecqi.healthit.gov/ecqms/PalliativeCare",
            "version" : "1.11.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "211",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "PalliativeCare" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.11.000'"," called ","PalliativeCare" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "212",
            "locator" : "10:1-10:46",
            "localIdentifier" : "Status",
            "path" : "http://ecqi.healthit.gov/ecqms/Status",
            "version" : "1.8.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "212",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Status" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.8.000'"," called ","Status" ]
                  } ]
               }
            } ]
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "223",
            "locator" : "23:1-23:49",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "223",
                  "s" : [ {
                     "value" : [ "","parameter ","\"Measurement Period\""," " ]
                  }, {
                     "r" : "224",
                     "s" : [ {
                        "value" : [ "Interval<" ]
                     }, {
                        "r" : "225",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  } ]
               }
            } ],
            "parameterTypeSpecifier" : {
               "localId" : "224",
               "locator" : "23:32-23:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "225",
                  "locator" : "23:41-23:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "213",
            "locator" : "12:1-12:132",
            "name" : "Congenital or Acquired Absence of Cervix",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "213",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Congenital or Acquired Absence of Cervix\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "214",
            "locator" : "13:1-13:116",
            "name" : "Home Healthcare Services",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "214",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Home Healthcare Services\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "215",
            "locator" : "14:1-14:100",
            "name" : "HPV Test",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "215",
                  "s" : [ {
                     "value" : [ "","valueset ","\"HPV Test\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "216",
            "locator" : "15:1-15:128",
            "name" : "Hysterectomy with No Residual Cervix",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "216",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Hysterectomy with No Residual Cervix\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "217",
            "locator" : "16:1-16:104",
            "name" : "Office Visit",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "217",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Office Visit\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "218",
            "locator" : "17:1-17:109",
            "name" : "Virtual Encounter",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "218",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Virtual Encounter\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "219",
            "locator" : "18:1-18:100",
            "name" : "Pap Test",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "219",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Pap Test\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "220",
            "locator" : "19:1-19:152",
            "name" : "Preventive Care Services Established Office Visit, 18 and Up",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "220",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Preventive Care Services Established Office Visit, 18 and Up\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "221",
            "locator" : "20:1-20:148",
            "name" : "Preventive Care Services Initial Office Visit, 18 and Up",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "221",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Preventive Care Services Initial Office Visit, 18 and Up\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "222",
            "locator" : "21:1-21:108",
            "name" : "Telephone Visits",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "222",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Telephone Visits\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         } ]
      },
      "contexts" : {
         "def" : [ {
            "localId" : "229",
            "locator" : "25:1-25:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "localId" : "227",
            "locator" : "25:1-25:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "localId" : "228",
               "type" : "SingletonFrom",
               "signature" : [ ],
               "operand" : {
                  "localId" : "226",
                  "locator" : "25:1-25:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient",
                  "type" : "Retrieve",
                  "include" : [ ],
                  "codeFilter" : [ ],
                  "dateFilter" : [ ],
                  "otherFilter" : [ ]
               }
            }
         }, {
            "localId" : "254",
            "locator" : "34:1-42:82",
            "name" : "Qualifying Encounters",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "254",
                  "s" : [ {
                     "value" : [ "","define ","\"Qualifying Encounters\"",":\n  " ]
                  }, {
                     "r" : "304",
                     "s" : [ {
                        "s" : [ {
                           "r" : "255",
                           "s" : [ {
                              "r" : "287",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "287",
                                 "s" : [ {
                                    "r" : "286",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "286",
                                       "s" : [ {
                                          "r" : "280",
                                          "s" : [ {
                                             "r" : "275",
                                             "s" : [ {
                                                "r" : "269",
                                                "s" : [ {
                                                   "r" : "264",
                                                   "s" : [ {
                                                      "r" : "258",
                                                      "s" : [ {
                                                         "value" : [ "[","\"Encounter\"",": " ]
                                                      }, {
                                                         "s" : [ {
                                                            "value" : [ "\"Office Visit\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "]" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n      union " ]
                                                   }, {
                                                      "r" : "262",
                                                      "s" : [ {
                                                         "value" : [ "[","Encounter",": " ]
                                                      }, {
                                                         "s" : [ {
                                                            "value" : [ "\"Preventive Care Services Established Office Visit, 18 and Up\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "]" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n      union " ]
                                                }, {
                                                   "r" : "267",
                                                   "s" : [ {
                                                      "value" : [ "[","Encounter",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Preventive Care Services Initial Office Visit, 18 and Up\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n      union " ]
                                             }, {
                                                "r" : "272",
                                                "s" : [ {
                                                   "value" : [ "[","Encounter",": " ]
                                                }, {
                                                   "s" : [ {
                                                      "value" : [ "\"Home Healthcare Services\"" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "\n      union " ]
                                          }, {
                                             "r" : "278",
                                             "s" : [ {
                                                "value" : [ "[","Encounter",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Telephone Visits\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n      union " ]
                                       }, {
                                          "r" : "283",
                                          "s" : [ {
                                             "value" : [ "[","Encounter",": " ]
                                          }, {
                                             "s" : [ {
                                                "value" : [ "\"Virtual Encounter\"" ]
                                             } ]
                                          }, {
                                             "value" : [ "]" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n  )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "287",
                                    "s" : [ {
                                       "value" : [ "isEncounterPerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","ValidEncounters" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "302",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "302",
                           "s" : [ {
                              "r" : "291",
                              "s" : [ {
                                 "r" : "290",
                                 "s" : [ {
                                    "r" : "288",
                                    "s" : [ {
                                       "value" : [ "ValidEncounters" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "290",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "291",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "302",
                              "value" : [ " ","during day of"," " ]
                           }, {
                              "r" : "301",
                              "s" : [ {
                                 "value" : [ "\"Measurement Period\"" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "304",
               "locator" : "35:3-42:82",
               "type" : "Query",
               "source" : [ {
                  "localId" : "255",
                  "locator" : "35:3-41:46",
                  "alias" : "ValidEncounters",
                  "expression" : {
                     "localId" : "287",
                     "locator" : "35:3-41:30",
                     "name" : "isEncounterPerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "286",
                        "locator" : "35:5-41:3",
                        "type" : "Union",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "275",
                           "locator" : "35:7-38:51",
                           "type" : "Union",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "264",
                              "locator" : "35:7-36:87",
                              "type" : "Union",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "258",
                                 "locator" : "35:7-35:35",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "257",
                                    "locator" : "35:21-35:34",
                                    "name" : "Office Visit",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              }, {
                                 "localId" : "262",
                                 "locator" : "36:13-36:87",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "261",
                                    "locator" : "36:25-36:86",
                                    "name" : "Preventive Care Services Established Office Visit, 18 and Up",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              } ]
                           }, {
                              "localId" : "274",
                              "type" : "Union",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "267",
                                 "locator" : "37:13-37:83",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "266",
                                    "locator" : "37:25-37:82",
                                    "name" : "Preventive Care Services Initial Office Visit, 18 and Up",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              }, {
                                 "localId" : "272",
                                 "locator" : "38:13-38:51",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "271",
                                    "locator" : "38:25-38:50",
                                    "name" : "Home Healthcare Services",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              } ]
                           } ]
                        }, {
                           "localId" : "285",
                           "type" : "Union",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "278",
                              "locator" : "39:13-39:43",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                              "codeProperty" : "type",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "277",
                                 "locator" : "39:25-39:42",
                                 "name" : "Telephone Visits",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }, {
                              "localId" : "283",
                              "locator" : "40:13-40:44",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                              "codeProperty" : "type",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "282",
                                 "locator" : "40:25-40:43",
                                 "name" : "Virtual Encounter",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           } ]
                        } ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "302",
                  "locator" : "42:5-42:82",
                  "precision" : "Day",
                  "type" : "IncludedIn",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "291",
                     "locator" : "42:11-42:47",
                     "name" : "toInterval",
                     "libraryName" : "QICoreCommon",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "292",
                        "type" : "As",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "290",
                           "locator" : "42:11-42:32",
                           "name" : "ToInterval",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "289",
                              "path" : "period",
                              "scope" : "ValidEncounters",
                              "type" : "Property"
                           } ]
                        },
                        "asTypeSpecifier" : {
                           "localId" : "293",
                           "type" : "ChoiceTypeSpecifier",
                           "type" : [ ],
                           "choice" : [ {
                              "localId" : "294",
                              "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                              "type" : "NamedTypeSpecifier"
                           }, {
                              "localId" : "295",
                              "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                              "type" : "NamedTypeSpecifier"
                           }, {
                              "localId" : "296",
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "localId" : "297",
                                 "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }, {
                              "localId" : "298",
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "localId" : "299",
                                 "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }, {
                              "localId" : "300",
                              "name" : "{http://hl7.org/fhir}Timing",
                              "type" : "NamedTypeSpecifier"
                           } ]
                        }
                     } ]
                  }, {
                     "localId" : "301",
                     "locator" : "42:63-42:82",
                     "name" : "Measurement Period",
                     "type" : "ParameterRef"
                  } ]
               }
            }
         }, {
            "localId" : "231",
            "locator" : "27:1-32:38",
            "name" : "Initial Population",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "231",
                  "s" : [ {
                     "value" : [ "","define ","\"Initial Population\"",":\n  " ]
                  }, {
                     "r" : "232",
                     "s" : [ {
                        "r" : "233",
                        "s" : [ {
                           "r" : "246",
                           "s" : [ {
                              "r" : "242",
                              "s" : [ {
                                 "value" : [ "AgeInYearsAt","(" ]
                              }, {
                                 "r" : "234",
                                 "s" : [ {
                                    "value" : [ "date from \n    " ]
                                 }, {
                                    "r" : "235",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "236",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n  )" ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "245",
                              "s" : [ {
                                 "r" : "243",
                                 "value" : [ "Interval[","24",", ","64","]" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    and " ]
                        }, {
                           "r" : "247",
                           "s" : [ {
                              "r" : "250",
                              "s" : [ {
                                 "r" : "248",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "250",
                                 "s" : [ {
                                    "value" : [ "gender" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "251",
                              "s" : [ {
                                 "value" : [ "'female'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    and " ]
                     }, {
                        "r" : "252",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "305",
                           "s" : [ {
                              "value" : [ "\"Qualifying Encounters\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "232",
               "locator" : "28:3-32:38",
               "type" : "And",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "233",
                  "locator" : "28:3-31:33",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "246",
                     "locator" : "28:3-30:23",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "242",
                        "locator" : "28:3-30:3",
                        "precision" : "Year",
                        "type" : "CalculateAgeAt",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "241",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "240",
                              "path" : "birthDate",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "239",
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           }
                        }, {
                           "localId" : "234",
                           "locator" : "28:16-29:31",
                           "type" : "DateFrom",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "235",
                              "locator" : "29:5-29:31",
                              "type" : "End",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "236",
                                 "locator" : "29:12-29:31",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "localId" : "245",
                        "locator" : "30:8-30:23",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "243",
                           "locator" : "30:17-30:18",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "24",
                           "type" : "Literal"
                        },
                        "high" : {
                           "localId" : "244",
                           "locator" : "30:21-30:22",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "64",
                           "type" : "Literal"
                        }
                     } ]
                  }, {
                     "localId" : "247",
                     "locator" : "31:9-31:33",
                     "type" : "Equal",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "250",
                        "locator" : "31:9-31:22",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "249",
                           "path" : "gender",
                           "type" : "Property",
                           "source" : {
                              "localId" : "248",
                              "locator" : "31:9-31:15",
                              "name" : "Patient",
                              "type" : "ExpressionRef"
                           }
                        }
                     }, {
                        "localId" : "251",
                        "locator" : "31:26-31:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "female",
                        "type" : "Literal"
                     } ]
                  } ]
               }, {
                  "localId" : "252",
                  "locator" : "32:9-32:38",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "305",
                     "locator" : "32:16-32:38",
                     "name" : "Qualifying Encounters",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "307",
            "locator" : "44:1-45:22",
            "name" : "Denominator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "307",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator\"",":\n  " ]
                  }, {
                     "r" : "308",
                     "s" : [ {
                        "value" : [ "\"Initial Population\"" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "308",
               "locator" : "45:3-45:22",
               "name" : "Initial Population",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "317",
            "locator" : "56:1-62:5",
            "name" : "Absence of Cervix",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "317",
                  "s" : [ {
                     "value" : [ "","define ","\"Absence of Cervix\"",":\n  " ]
                  }, {
                     "r" : "355",
                     "s" : [ {
                        "r" : "332",
                        "s" : [ {
                           "value" : [ "( " ]
                        }, {
                           "r" : "332",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "318",
                                 "s" : [ {
                                    "r" : "323",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "323",
                                       "s" : [ {
                                          "r" : "321",
                                          "s" : [ {
                                             "value" : [ "( " ]
                                          }, {
                                             "r" : "321",
                                             "s" : [ {
                                                "value" : [ "[","Procedure",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Hysterectomy with No Residual Cervix\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          }, {
                                             "value" : [ " )" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "323",
                                          "s" : [ {
                                             "value" : [ "isProcedurePerformed"," ( )" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ " ","NoCervixProcedure" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "331",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "331",
                                 "s" : [ {
                                    "r" : "327",
                                    "s" : [ {
                                       "r" : "326",
                                       "s" : [ {
                                          "r" : "324",
                                          "s" : [ {
                                             "value" : [ "NoCervixProcedure" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "326",
                                          "s" : [ {
                                             "value" : [ "performed" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "327",
                                       "s" : [ {
                                          "value" : [ "toInterval"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "331",
                                    "value" : [ " ","ends on or before"," " ]
                                 }, {
                                    "r" : "328",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "329",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     }, {
                        "value" : [ "\n    union " ]
                     }, {
                        "r" : "344",
                        "s" : [ {
                           "value" : [ "( " ]
                        }, {
                           "r" : "344",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "333",
                                 "s" : [ {
                                    "r" : "336",
                                    "s" : [ {
                                       "r" : "336",
                                       "s" : [ {
                                          "value" : [ "[","Condition",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Congenital or Acquired Absence of Cervix\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","NoCervixDiagnosis" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n        " ]
                           }, {
                              "r" : "343",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "343",
                                 "s" : [ {
                                    "r" : "339",
                                    "s" : [ {
                                       "r" : "338",
                                       "s" : [ {
                                          "value" : [ "NoCervixDiagnosis" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "339",
                                       "s" : [ {
                                          "value" : [ "prevalenceInterval"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "343",
                                    "value" : [ " ","starts on or before"," " ]
                                 }, {
                                    "r" : "340",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "341",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "355",
               "locator" : "57:3-62:5",
               "type" : "Union",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "345",
                  "type" : "As",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "332",
                     "locator" : "57:3-59:3",
                     "type" : "Query",
                     "source" : [ {
                        "localId" : "318",
                        "locator" : "57:5-57:106",
                        "alias" : "NoCervixProcedure",
                        "expression" : {
                           "localId" : "323",
                           "locator" : "57:5-57:88",
                           "name" : "isProcedurePerformed",
                           "libraryName" : "Status",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "321",
                              "locator" : "57:7-57:61",
                              "dataType" : "{http://hl7.org/fhir}Procedure",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "320",
                                 "locator" : "57:21-57:58",
                                 "name" : "Hysterectomy with No Residual Cervix",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           } ]
                        }
                     } ],
                     "let" : [ ],
                     "relationship" : [ ],
                     "where" : {
                        "localId" : "331",
                        "locator" : "58:7-58:100",
                        "type" : "SameOrBefore",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "330",
                           "locator" : "58:56-58:59",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "327",
                              "locator" : "58:13-58:54",
                              "name" : "toInterval",
                              "libraryName" : "QICoreCommon",
                              "type" : "FunctionRef",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "326",
                                 "locator" : "58:13-58:39",
                                 "name" : "ToValue",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "325",
                                    "path" : "performed",
                                    "scope" : "NoCervixProcedure",
                                    "type" : "Property"
                                 } ]
                              } ]
                           }
                        }, {
                           "localId" : "328",
                           "locator" : "58:74-58:100",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "329",
                              "locator" : "58:81-58:100",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        } ]
                     }
                  },
                  "asTypeSpecifier" : {
                     "localId" : "346",
                     "type" : "ListTypeSpecifier",
                     "elementType" : {
                        "localId" : "347",
                        "type" : "ChoiceTypeSpecifier",
                        "type" : [ ],
                        "choice" : [ {
                           "localId" : "348",
                           "name" : "{http://hl7.org/fhir}Procedure",
                           "type" : "NamedTypeSpecifier"
                        }, {
                           "localId" : "349",
                           "name" : "{http://hl7.org/fhir}Condition",
                           "type" : "NamedTypeSpecifier"
                        } ]
                     }
                  }
               }, {
                  "localId" : "350",
                  "type" : "As",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "344",
                     "locator" : "60:11-62:5",
                     "type" : "Query",
                     "source" : [ {
                        "localId" : "333",
                        "locator" : "60:13-60:85",
                        "alias" : "NoCervixDiagnosis",
                        "expression" : {
                           "localId" : "336",
                           "locator" : "60:13-60:67",
                           "dataType" : "{http://hl7.org/fhir}Condition",
                           "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                           "codeProperty" : "code",
                           "codeComparator" : "in",
                           "type" : "Retrieve",
                           "codes" : {
                              "localId" : "335",
                              "locator" : "60:25-60:66",
                              "name" : "Congenital or Acquired Absence of Cervix",
                              "preserve" : true,
                              "type" : "ValueSetRef"
                           },
                           "include" : [ ],
                           "codeFilter" : [ ],
                           "dateFilter" : [ ],
                           "otherFilter" : [ ]
                        }
                     } ],
                     "let" : [ ],
                     "relationship" : [ ],
                     "where" : {
                        "localId" : "343",
                        "locator" : "61:9-61:102",
                        "type" : "SameOrBefore",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "342",
                           "locator" : "61:56-61:61",
                           "type" : "Start",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "339",
                              "locator" : "61:15-61:54",
                              "name" : "prevalenceInterval",
                              "libraryName" : "QICoreCommon",
                              "type" : "FunctionRef",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "338",
                                 "locator" : "61:15-61:31",
                                 "name" : "NoCervixDiagnosis",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }, {
                           "localId" : "340",
                           "locator" : "61:76-61:102",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "341",
                              "locator" : "61:83-61:102",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        } ]
                     }
                  },
                  "asTypeSpecifier" : {
                     "localId" : "351",
                     "type" : "ListTypeSpecifier",
                     "elementType" : {
                        "localId" : "352",
                        "type" : "ChoiceTypeSpecifier",
                        "type" : [ ],
                        "choice" : [ {
                           "localId" : "353",
                           "name" : "{http://hl7.org/fhir}Procedure",
                           "type" : "NamedTypeSpecifier"
                        }, {
                           "localId" : "354",
                           "name" : "{http://hl7.org/fhir}Condition",
                           "type" : "NamedTypeSpecifier"
                        } ]
                     }
                  }
               } ]
            }
         }, {
            "localId" : "310",
            "locator" : "47:1-50:69",
            "name" : "Denominator Exclusions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "310",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator Exclusions\"",":\n  " ]
                  }, {
                     "r" : "311",
                     "s" : [ {
                        "r" : "312",
                        "s" : [ {
                           "r" : "314",
                           "s" : [ {
                              "r" : "313",
                              "s" : [ {
                                 "value" : [ "Hospice" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "314",
                              "s" : [ {
                                 "value" : [ "\"Has Hospice Services\"" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "315",
                           "s" : [ {
                              "value" : [ "exists " ]
                           }, {
                              "r" : "356",
                              "s" : [ {
                                 "value" : [ "\"Absence of Cervix\"" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    or " ]
                     }, {
                        "r" : "358",
                        "s" : [ {
                           "r" : "357",
                           "s" : [ {
                              "value" : [ "PalliativeCare" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "358",
                           "s" : [ {
                              "value" : [ "\"Has Palliative Care in the Measurement Period\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "311",
               "locator" : "48:3-50:69",
               "type" : "Or",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "312",
                  "locator" : "48:3-49:33",
                  "type" : "Or",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "314",
                     "locator" : "48:3-48:32",
                     "name" : "Has Hospice Services",
                     "libraryName" : "Hospice",
                     "type" : "ExpressionRef"
                  }, {
                     "localId" : "315",
                     "locator" : "49:8-49:33",
                     "type" : "Exists",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "356",
                        "locator" : "49:15-49:33",
                        "name" : "Absence of Cervix",
                        "type" : "ExpressionRef"
                     }
                  } ]
               }, {
                  "localId" : "358",
                  "locator" : "50:8-50:69",
                  "name" : "Has Palliative Care in the Measurement Period",
                  "libraryName" : "PalliativeCare",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "364",
            "locator" : "64:1-67:44",
            "name" : "Cervical Cytology Within 3 Years",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "364",
                  "s" : [ {
                     "value" : [ "","define ","\"Cervical Cytology Within 3 Years\"",":\n  " ]
                  }, {
                     "r" : "436",
                     "s" : [ {
                        "s" : [ {
                           "r" : "365",
                           "s" : [ {
                              "r" : "370",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "370",
                                 "s" : [ {
                                    "r" : "368",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "368",
                                       "s" : [ {
                                          "value" : [ "[","Observation",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Pap Test\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "370",
                                    "s" : [ {
                                       "value" : [ "isLaboratoryTestPerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","CervicalCytology" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "371",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "371",
                           "s" : [ {
                              "r" : "430",
                              "s" : [ {
                                 "r" : "375",
                                 "s" : [ {
                                    "r" : "374",
                                    "s" : [ {
                                       "r" : "372",
                                       "s" : [ {
                                          "value" : [ "CervicalCytology" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "374",
                                       "s" : [ {
                                          "value" : [ "effective" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "375",
                                    "s" : [ {
                                       "value" : [ "latest"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "430",
                                 "value" : [ " ","during day of"," " ]
                              }, {
                                 "r" : "428",
                                 "s" : [ {
                                    "value" : [ "Interval[" ]
                                 }, {
                                    "r" : "422",
                                    "s" : [ {
                                       "r" : "423",
                                       "s" : [ {
                                          "value" : [ "start of " ]
                                       }, {
                                          "r" : "424",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " - " ]
                                    }, {
                                       "r" : "425",
                                       "s" : [ {
                                          "value" : [ "2 ","years" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "426",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "427",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "435",
                              "s" : [ {
                                 "r" : "433",
                                 "s" : [ {
                                    "r" : "431",
                                    "s" : [ {
                                       "value" : [ "CervicalCytology" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "433",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " is not null" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "436",
               "locator" : "65:3-67:44",
               "type" : "Query",
               "source" : [ {
                  "localId" : "365",
                  "locator" : "65:3-65:82",
                  "alias" : "CervicalCytology",
                  "expression" : {
                     "localId" : "370",
                     "locator" : "65:3-65:65",
                     "name" : "isLaboratoryTestPerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "368",
                        "locator" : "65:5-65:33",
                        "dataType" : "{http://hl7.org/fhir}Observation",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "367",
                           "locator" : "65:21-65:30",
                           "name" : "Pap Test",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "371",
                  "locator" : "66:5-67:44",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "430",
                     "locator" : "66:11-66:140",
                     "precision" : "Day",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "375",
                        "locator" : "66:11-66:47",
                        "name" : "latest",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "385",
                           "type" : "Case",
                           "caseItem" : [ {
                              "localId" : "386",
                              "when" : {
                                 "localId" : "387",
                                 "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "Is",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "374",
                                    "locator" : "66:11-66:36",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "373",
                                       "path" : "effective",
                                       "scope" : "CervicalCytology",
                                       "type" : "Property"
                                    } ]
                                 }
                              },
                              "then" : {
                                 "localId" : "377",
                                 "type" : "As",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "376",
                                    "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "374",
                                       "locator" : "66:11-66:36",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "373",
                                          "path" : "effective",
                                          "scope" : "CervicalCytology",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "localId" : "378",
                                    "type" : "ChoiceTypeSpecifier",
                                    "type" : [ ],
                                    "choice" : [ {
                                       "localId" : "379",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "380",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "381",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "382",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "localId" : "383",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "384",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           }, {
                              "localId" : "388",
                              "when" : {
                                 "localId" : "389",
                                 "type" : "Is",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "374",
                                    "locator" : "66:11-66:36",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "373",
                                       "path" : "effective",
                                       "scope" : "CervicalCytology",
                                       "type" : "Property"
                                    } ]
                                 },
                                 "isTypeSpecifier" : {
                                    "localId" : "390",
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "localId" : "391",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "localId" : "395",
                                 "type" : "As",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "392",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "374",
                                       "locator" : "66:11-66:36",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "373",
                                          "path" : "effective",
                                          "scope" : "CervicalCytology",
                                          "type" : "Property"
                                       } ]
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "393",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "394",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "localId" : "396",
                                    "type" : "ChoiceTypeSpecifier",
                                    "type" : [ ],
                                    "choice" : [ {
                                       "localId" : "397",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "398",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "399",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "400",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "localId" : "401",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "402",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           }, {
                              "localId" : "403",
                              "when" : {
                                 "localId" : "404",
                                 "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "Is",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "374",
                                    "locator" : "66:11-66:36",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "373",
                                       "path" : "effective",
                                       "scope" : "CervicalCytology",
                                       "type" : "Property"
                                    } ]
                                 }
                              },
                              "then" : {
                                 "localId" : "406",
                                 "type" : "As",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "405",
                                    "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "374",
                                       "locator" : "66:11-66:36",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "373",
                                          "path" : "effective",
                                          "scope" : "CervicalCytology",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "localId" : "407",
                                    "type" : "ChoiceTypeSpecifier",
                                    "type" : [ ],
                                    "choice" : [ {
                                       "localId" : "408",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "409",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "410",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "411",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "localId" : "412",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "413",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           } ],
                           "else" : {
                              "localId" : "414",
                              "type" : "Null"
                           }
                        } ]
                     }, {
                        "localId" : "428",
                        "locator" : "66:63-66:140",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "422",
                           "locator" : "66:72-66:110",
                           "type" : "Subtract",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "423",
                              "locator" : "66:72-66:100",
                              "type" : "Start",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "424",
                                 "locator" : "66:81-66:100",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }, {
                              "localId" : "425",
                              "locator" : "66:104-66:110",
                              "value" : 2,
                              "unit" : "years",
                              "type" : "Quantity"
                           } ]
                        },
                        "high" : {
                           "localId" : "426",
                           "locator" : "66:113-66:139",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "427",
                              "locator" : "66:120-66:139",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        }
                     } ]
                  }, {
                     "localId" : "435",
                     "locator" : "67:11-67:44",
                     "type" : "Not",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "434",
                        "locator" : "67:11-67:44",
                        "type" : "IsNull",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "433",
                           "locator" : "67:11-67:32",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "432",
                              "path" : "value",
                              "scope" : "CervicalCytology",
                              "type" : "Property"
                           } ]
                        }
                     }
                  } ]
               }
            }
         }, {
            "localId" : "440",
            "locator" : "69:1-73:35",
            "name" : "HPV Test Within 5 Years for Women Age 30 and Older",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "440",
                  "s" : [ {
                     "value" : [ "","define ","\"HPV Test Within 5 Years for Women Age 30 and Older\"",":\n  " ]
                  }, {
                     "r" : "572",
                     "s" : [ {
                        "s" : [ {
                           "r" : "441",
                           "s" : [ {
                              "r" : "446",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "446",
                                 "s" : [ {
                                    "r" : "444",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "444",
                                       "s" : [ {
                                          "value" : [ "[","Observation",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"HPV Test\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "446",
                                    "s" : [ {
                                       "value" : [ "isLaboratoryTestPerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","HPVTest" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "447",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "447",
                           "s" : [ {
                              "r" : "448",
                              "s" : [ {
                                 "r" : "449",
                                 "s" : [ {
                                    "r" : "506",
                                    "s" : [ {
                                       "value" : [ "AgeInYearsAt","(" ]
                                    }, {
                                       "r" : "450",
                                       "s" : [ {
                                          "value" : [ "date from " ]
                                       }, {
                                          "r" : "454",
                                          "s" : [ {
                                             "r" : "453",
                                             "s" : [ {
                                                "r" : "451",
                                                "s" : [ {
                                                   "value" : [ "HPVTest" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "453",
                                                "s" : [ {
                                                   "value" : [ "effective" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "454",
                                             "s" : [ {
                                                "value" : [ "latest","()" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "r" : "507",
                                    "value" : [ " ",">="," ","30" ]
                                 } ]
                              }, {
                                 "value" : [ "\n      and " ]
                              }, {
                                 "r" : "566",
                                 "s" : [ {
                                    "r" : "511",
                                    "s" : [ {
                                       "r" : "510",
                                       "s" : [ {
                                          "r" : "508",
                                          "s" : [ {
                                             "value" : [ "HPVTest" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "510",
                                          "s" : [ {
                                             "value" : [ "effective" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "511",
                                       "s" : [ {
                                          "value" : [ "latest"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "566",
                                    "value" : [ " ","during day of"," " ]
                                 }, {
                                    "r" : "564",
                                    "s" : [ {
                                       "value" : [ "Interval[" ]
                                    }, {
                                       "r" : "558",
                                       "s" : [ {
                                          "r" : "559",
                                          "s" : [ {
                                             "value" : [ "start of " ]
                                          }, {
                                             "r" : "560",
                                             "s" : [ {
                                                "value" : [ "\"Measurement Period\"" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " - " ]
                                       }, {
                                          "r" : "561",
                                          "s" : [ {
                                             "value" : [ "4 ","years" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "562",
                                       "s" : [ {
                                          "value" : [ "end of " ]
                                       }, {
                                          "r" : "563",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "571",
                              "s" : [ {
                                 "r" : "569",
                                 "s" : [ {
                                    "r" : "567",
                                    "s" : [ {
                                       "value" : [ "HPVTest" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "569",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " is not null" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "572",
               "locator" : "70:3-73:35",
               "type" : "Query",
               "source" : [ {
                  "localId" : "441",
                  "locator" : "70:3-70:73",
                  "alias" : "HPVTest",
                  "expression" : {
                     "localId" : "446",
                     "locator" : "70:3-70:65",
                     "name" : "isLaboratoryTestPerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "444",
                        "locator" : "70:5-70:33",
                        "dataType" : "{http://hl7.org/fhir}Observation",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "443",
                           "locator" : "70:21-70:30",
                           "name" : "HPV Test",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "447",
                  "locator" : "71:5-73:35",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "448",
                     "locator" : "71:11-72:131",
                     "type" : "And",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "449",
                        "locator" : "71:11-71:66",
                        "type" : "GreaterOrEqual",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "506",
                           "locator" : "71:11-71:60",
                           "precision" : "Year",
                           "type" : "CalculateAgeAt",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "505",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "504",
                                 "path" : "birthDate",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "503",
                                    "name" : "Patient",
                                    "type" : "ExpressionRef"
                                 }
                              }
                           }, {
                              "localId" : "450",
                              "locator" : "71:24-71:59",
                              "type" : "DateFrom",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "454",
                                 "locator" : "71:34-71:59",
                                 "name" : "latest",
                                 "libraryName" : "QICoreCommon",
                                 "type" : "FunctionRef",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "464",
                                    "type" : "Case",
                                    "caseItem" : [ {
                                       "localId" : "465",
                                       "when" : {
                                          "localId" : "466",
                                          "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "Is",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "453",
                                             "locator" : "71:34-71:50",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "signature" : [ ],
                                             "operand" : [ {
                                                "localId" : "452",
                                                "path" : "effective",
                                                "scope" : "HPVTest",
                                                "type" : "Property"
                                             } ]
                                          }
                                       },
                                       "then" : {
                                          "localId" : "456",
                                          "type" : "As",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "455",
                                             "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "As",
                                             "signature" : [ ],
                                             "operand" : {
                                                "localId" : "453",
                                                "locator" : "71:34-71:50",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "signature" : [ ],
                                                "operand" : [ {
                                                   "localId" : "452",
                                                   "path" : "effective",
                                                   "scope" : "HPVTest",
                                                   "type" : "Property"
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "457",
                                             "type" : "ChoiceTypeSpecifier",
                                             "type" : [ ],
                                             "choice" : [ {
                                                "localId" : "458",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "459",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "460",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "461",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }, {
                                                "localId" : "462",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "463",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }
                                       }
                                    }, {
                                       "localId" : "467",
                                       "when" : {
                                          "localId" : "468",
                                          "type" : "Is",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "453",
                                             "locator" : "71:34-71:50",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "signature" : [ ],
                                             "operand" : [ {
                                                "localId" : "452",
                                                "path" : "effective",
                                                "scope" : "HPVTest",
                                                "type" : "Property"
                                             } ]
                                          },
                                          "isTypeSpecifier" : {
                                             "localId" : "469",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "470",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       },
                                       "then" : {
                                          "localId" : "474",
                                          "type" : "As",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "471",
                                             "type" : "As",
                                             "signature" : [ ],
                                             "operand" : {
                                                "localId" : "453",
                                                "locator" : "71:34-71:50",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "signature" : [ ],
                                                "operand" : [ {
                                                   "localId" : "452",
                                                   "path" : "effective",
                                                   "scope" : "HPVTest",
                                                   "type" : "Property"
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "472",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "473",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "475",
                                             "type" : "ChoiceTypeSpecifier",
                                             "type" : [ ],
                                             "choice" : [ {
                                                "localId" : "476",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "477",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "478",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "479",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }, {
                                                "localId" : "480",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "481",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }
                                       }
                                    }, {
                                       "localId" : "482",
                                       "when" : {
                                          "localId" : "483",
                                          "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "Is",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "453",
                                             "locator" : "71:34-71:50",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "signature" : [ ],
                                             "operand" : [ {
                                                "localId" : "452",
                                                "path" : "effective",
                                                "scope" : "HPVTest",
                                                "type" : "Property"
                                             } ]
                                          }
                                       },
                                       "then" : {
                                          "localId" : "485",
                                          "type" : "As",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "484",
                                             "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "As",
                                             "signature" : [ ],
                                             "operand" : {
                                                "localId" : "453",
                                                "locator" : "71:34-71:50",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "signature" : [ ],
                                                "operand" : [ {
                                                   "localId" : "452",
                                                   "path" : "effective",
                                                   "scope" : "HPVTest",
                                                   "type" : "Property"
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "486",
                                             "type" : "ChoiceTypeSpecifier",
                                             "type" : [ ],
                                             "choice" : [ {
                                                "localId" : "487",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "488",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "489",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "490",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }, {
                                                "localId" : "491",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "492",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }
                                       }
                                    } ],
                                    "else" : {
                                       "localId" : "493",
                                       "type" : "Null"
                                    }
                                 } ]
                              }
                           } ]
                        }, {
                           "localId" : "507",
                           "locator" : "71:65-71:66",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "30",
                           "type" : "Literal"
                        } ]
                     }, {
                        "localId" : "566",
                        "locator" : "72:11-72:131",
                        "precision" : "Day",
                        "type" : "In",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "511",
                           "locator" : "72:11-72:38",
                           "name" : "latest",
                           "libraryName" : "QICoreCommon",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "521",
                              "type" : "Case",
                              "caseItem" : [ {
                                 "localId" : "522",
                                 "when" : {
                                    "localId" : "523",
                                    "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "Is",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "510",
                                       "locator" : "72:11-72:27",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "509",
                                          "path" : "effective",
                                          "scope" : "HPVTest",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "then" : {
                                    "localId" : "513",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "512",
                                       "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "As",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "510",
                                          "locator" : "72:11-72:27",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "509",
                                             "path" : "effective",
                                             "scope" : "HPVTest",
                                             "type" : "Property"
                                          } ]
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "514",
                                       "type" : "ChoiceTypeSpecifier",
                                       "type" : [ ],
                                       "choice" : [ {
                                          "localId" : "515",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "516",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "517",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "518",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }, {
                                          "localId" : "519",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "520",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }
                                 }
                              }, {
                                 "localId" : "524",
                                 "when" : {
                                    "localId" : "525",
                                    "type" : "Is",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "510",
                                       "locator" : "72:11-72:27",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "509",
                                          "path" : "effective",
                                          "scope" : "HPVTest",
                                          "type" : "Property"
                                       } ]
                                    },
                                    "isTypeSpecifier" : {
                                       "localId" : "526",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "527",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "then" : {
                                    "localId" : "531",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "528",
                                       "type" : "As",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "510",
                                          "locator" : "72:11-72:27",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "509",
                                             "path" : "effective",
                                             "scope" : "HPVTest",
                                             "type" : "Property"
                                          } ]
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "529",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "530",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "532",
                                       "type" : "ChoiceTypeSpecifier",
                                       "type" : [ ],
                                       "choice" : [ {
                                          "localId" : "533",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "534",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "535",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "536",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }, {
                                          "localId" : "537",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "538",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }
                                 }
                              }, {
                                 "localId" : "539",
                                 "when" : {
                                    "localId" : "540",
                                    "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "Is",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "510",
                                       "locator" : "72:11-72:27",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "509",
                                          "path" : "effective",
                                          "scope" : "HPVTest",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "then" : {
                                    "localId" : "542",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "541",
                                       "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "As",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "510",
                                          "locator" : "72:11-72:27",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "509",
                                             "path" : "effective",
                                             "scope" : "HPVTest",
                                             "type" : "Property"
                                          } ]
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "543",
                                       "type" : "ChoiceTypeSpecifier",
                                       "type" : [ ],
                                       "choice" : [ {
                                          "localId" : "544",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "545",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "546",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "547",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }, {
                                          "localId" : "548",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "549",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }
                                 }
                              } ],
                              "else" : {
                                 "localId" : "550",
                                 "type" : "Null"
                              }
                           } ]
                        }, {
                           "localId" : "564",
                           "locator" : "72:54-72:131",
                           "lowClosed" : true,
                           "highClosed" : true,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "558",
                              "locator" : "72:63-72:101",
                              "type" : "Subtract",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "559",
                                 "locator" : "72:63-72:91",
                                 "type" : "Start",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "560",
                                    "locator" : "72:72-72:91",
                                    "name" : "Measurement Period",
                                    "type" : "ParameterRef"
                                 }
                              }, {
                                 "localId" : "561",
                                 "locator" : "72:95-72:101",
                                 "value" : 4,
                                 "unit" : "years",
                                 "type" : "Quantity"
                              } ]
                           },
                           "high" : {
                              "localId" : "562",
                              "locator" : "72:104-72:130",
                              "type" : "End",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "563",
                                 "locator" : "72:111-72:130",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     } ]
                  }, {
                     "localId" : "571",
                     "locator" : "73:11-73:35",
                     "type" : "Not",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "570",
                        "locator" : "73:11-73:35",
                        "type" : "IsNull",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "569",
                           "locator" : "73:11-73:23",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "568",
                              "path" : "value",
                              "scope" : "HPVTest",
                              "type" : "Property"
                           } ]
                        }
                     }
                  } ]
               }
            }
         }, {
            "localId" : "360",
            "locator" : "52:1-54:66",
            "name" : "Numerator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "360",
                  "s" : [ {
                     "value" : [ "","define ","\"Numerator\"",":\n  " ]
                  }, {
                     "r" : "361",
                     "s" : [ {
                        "r" : "362",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "437",
                           "s" : [ {
                              "value" : [ "\"Cervical Cytology Within 3 Years\"" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    or " ]
                     }, {
                        "r" : "438",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "573",
                           "s" : [ {
                              "value" : [ "\"HPV Test Within 5 Years for Women Age 30 and Older\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "361",
               "locator" : "53:3-54:66",
               "type" : "Or",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "362",
                  "locator" : "53:3-53:43",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "437",
                     "locator" : "53:10-53:43",
                     "name" : "Cervical Cytology Within 3 Years",
                     "type" : "ExpressionRef"
                  }
               }, {
                  "localId" : "438",
                  "locator" : "54:8-54:66",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "573",
                     "locator" : "54:15-54:66",
                     "name" : "HPV Test Within 5 Years for Women Age 30 and Older",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "575",
            "locator" : "75:1-76:21",
            "name" : "SDE Ethnicity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "575",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Ethnicity\"",":\n  " ]
                  }, {
                     "r" : "577",
                     "s" : [ {
                        "r" : "576",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "577",
                        "s" : [ {
                           "value" : [ "\"SDE Ethnicity\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "577",
               "locator" : "76:3-76:21",
               "name" : "SDE Ethnicity",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "579",
            "locator" : "78:1-79:17",
            "name" : "SDE Payer",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "579",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Payer\"",":\n  " ]
                  }, {
                     "r" : "581",
                     "s" : [ {
                        "r" : "580",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "581",
                        "s" : [ {
                           "value" : [ "\"SDE Payer\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "581",
               "locator" : "79:3-79:17",
               "name" : "SDE Payer",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "583",
            "locator" : "81:1-82:16",
            "name" : "SDE Race",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "583",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Race\"",":\n  " ]
                  }, {
                     "r" : "585",
                     "s" : [ {
                        "r" : "584",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "585",
                        "s" : [ {
                           "value" : [ "\"SDE Race\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "585",
               "locator" : "82:3-82:16",
               "name" : "SDE Race",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "587",
            "locator" : "84:1-85:15",
            "name" : "SDE Sex",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "587",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Sex\"",":\n  " ]
                  }, {
                     "r" : "589",
                     "s" : [ {
                        "r" : "588",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "589",
                        "s" : [ {
                           "value" : [ "\"SDE Sex\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "589",
               "locator" : "85:3-85:15",
               "name" : "SDE Sex",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         } ]
      }
   }
}" + } + ] + }, + "request": { + "method": "PUT", + "url": "Library/CervicalCancerScreeningFHIR" + } + }, + { + "fullUrl": "https://madie.cms.gov/Measure/BreastCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Measure", + "id": "BreastCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/publishable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/executable-measure-cqfm" + ] + }, + "contained": [ + { + "resourceType": "Library", + "id": "effective-data-requirements", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428361000124107", + "display": "Discharge to home for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428371000124100", + "display": "Discharge to healthcare facility for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/observation-category", + "code": "survey", + "display": "survey" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "373066001", + "display": "Yes (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "24028007", + "display": "Right (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "7771000", + "display": "Left (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "98181-1", + "display": "Medical equipment used" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "160734000", + "display": "Lives in a nursing home (finding)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "October 1 Two Years Prior to the Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"October 1 Two Years Prior to the Measurement Period\":\n DateTime((year from start of \"Measurement Period\" - 2), 10, 1, 0, 0, 0, 0, 0)" + }, + { + "url": "displaySequence", + "valueInteger": 0 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Numerator" + }, + { + "url": "statement", + "valueString": "define \"Numerator\":\n exists ( ( ( [Observation: \"Mammography\"] ).isDiagnosticStudyPerformed ( ) ) Mammogram\n where Mammogram.effective.toInterval ( ) ends during day of Interval[\"October 1 Two Years Prior to the Measurement Period\", end of \"Measurement Period\"]\n )" + }, + { + "url": "displaySequence", + "valueInteger": 1 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdultOutpatientEncounters" + }, + { + "url": "name", + "valueString": "Qualifying Encounters" + }, + { + "url": "statement", + "valueString": "define \"Qualifying Encounters\":\n ( ( [Encounter: \"Office Visit\"]\n union [Encounter: \"Annual Wellness Visit\"]\n union [Encounter: \"Preventive Care Services Established Office Visit, 18 and Up\"]\n union [Encounter: \"Preventive Care Services Initial Office Visit, 18 and Up\"]\n union [Encounter: \"Home Healthcare Services\"]\n union [Encounter: \"Virtual Encounter\"]\n union [Encounter: \"Telephone Visits\"] ).isEncounterPerformed() ) ValidEncounter\n where ValidEncounter.period.toInterval() during day of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 2 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Initial Population" + }, + { + "url": "statement", + "valueString": "define \"Initial Population\":\n AgeInYearsAt(date from \n end of \"Measurement Period\"\n ) in Interval[52, 74]\n and Patient.gender = 'female'\n and exists AdultOutpatientEncounters.\"Qualifying Encounters\"" + }, + { + "url": "displaySequence", + "valueInteger": 3 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator" + }, + { + "url": "statement", + "valueString": "define \"Denominator\":\n \"Initial Population\"" + }, + { + "url": "displaySequence", + "valueInteger": 4 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Hospice" + }, + { + "url": "name", + "valueString": "Has Hospice Services" + }, + { + "url": "statement", + "valueString": "define \"Has Hospice Services\":\n exists ((([Encounter: \"Encounter Inpatient\"]).isEncounterPerformed()) InpatientEncounter\n where (InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to home for hospice care (procedure)\"\n or InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to healthcare facility for hospice care (procedure)\"\n )\n and InpatientEncounter.period.toInterval() ends during day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Hospice Encounter\"]).isEncounterPerformed()) HospiceEncounter\n where HospiceEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Observation: \"Hospice care [Minimum Data Set]\"]).isAssessmentPerformed()) HospiceAssessment\n where HospiceAssessment.value ~ \"Yes (qualifier value)\"\n and HospiceAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([ServiceRequest: \"Hospice Care Ambulatory\"]).isInterventionOrder()) HospiceOrder\n where HospiceOrder.authoredOn.toInterval() during day of \"Measurement Period\"\n // and HospiceOrder.doNotPerform is not true\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-447\n )\n or exists ((([Procedure: \"Hospice Care Ambulatory\"]).isInterventionPerformed()) HospicePerformed\n where HospicePerformed.performed.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists (([Condition: \"Hospice Diagnosis\"]) HospiceCareDiagnosis\n where HospiceCareDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 5 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Right Mastectomy Diagnosis" + }, + { + "url": "statement", + "valueString": "define \"Right Mastectomy Diagnosis\":\n ( [Condition: \"Status Post Right Mastectomy\"] RightMastectomyProcedure\n union ( [Condition: \"Unilateral Mastectomy, Unspecified Laterality\"] UnilateralMastectomyDiagnosis\n where exists ( UnilateralMastectomyDiagnosis.bodySite S\n where S ~ \"Right (qualifier value)\"\n )\n ) ) RightMastectomy\n where RightMastectomy.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 6 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Right Mastectomy Procedure" + }, + { + "url": "statement", + "valueString": "define \"Right Mastectomy Procedure\":\n ( ( [Procedure: \"Unilateral Mastectomy Right\"] ).isProcedurePerformed ( ) ) UnilateralMastectomyRightPerformed\n where UnilateralMastectomyRightPerformed.performed.toInterval ( ) ends on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 7 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Left Mastectomy Diagnosis" + }, + { + "url": "statement", + "valueString": "define \"Left Mastectomy Diagnosis\":\n ( [Condition: \"Status Post Left Mastectomy\"]\n union ( [Condition: \"Unilateral Mastectomy, Unspecified Laterality\"] UnilateralMastectomyDiagnosis\n where exists ( UnilateralMastectomyDiagnosis.bodySite S\n where S ~ \"Left (qualifier value)\"\n )\n ) ) LeftMastectomy\n where LeftMastectomy.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 8 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Left Mastectomy Procedure" + }, + { + "url": "statement", + "valueString": "define \"Left Mastectomy Procedure\":\n ( ( [Procedure: \"Unilateral Mastectomy Left\"] ).isProcedurePerformed ( ) ) UnilateralMastectomyLeftPerformed\n where UnilateralMastectomyLeftPerformed.performed.toInterval ( ) ends on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 9 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Bilateral Mastectomy Diagnosis" + }, + { + "url": "statement", + "valueString": "define \"Bilateral Mastectomy Diagnosis\":\n [Condition: \"History of bilateral mastectomy\"] BilateralMastectomyHistory\n where BilateralMastectomyHistory.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 10 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Bilateral Mastectomy Procedure" + }, + { + "url": "statement", + "valueString": "define \"Bilateral Mastectomy Procedure\":\n ( ( [Procedure: \"Bilateral Mastectomy\"] ).isProcedurePerformed ( ) ) BilateralMastectomyPerformed\n where BilateralMastectomyPerformed.performed.toInterval ( ) ends on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 11 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Has Criteria Indicating Frailty" + }, + { + "url": "statement", + "valueString": "define \"Has Criteria Indicating Frailty\":\n exists ( (([DeviceRequest: \"Frailty Device\"]).isDeviceOrder()) FrailtyDeviceOrder\n where FrailtyDeviceOrder.doNotPerform() is not true\n and FrailtyDeviceOrder.authoredOn.toInterval() during day of \"Measurement Period\"\n )\n or exists ( (([Observation: \"Medical equipment used\"]).isAssessmentPerformed()) EquipmentUsed\n where EquipmentUsed.value as Concept in \"Frailty Device\" \n and EquipmentUsed.effective.toInterval() ends during day of \"Measurement Period\"\n )\n or exists ( ([Condition: \"Frailty Diagnosis\"]) FrailtyDiagnosis\n where FrailtyDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )\n or exists ( (([Encounter: \"Frailty Encounter\"]).isEncounterPerformed()) FrailtyEncounter\n where FrailtyEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ( (([Observation: \"Frailty Symptom\"]).isSymptom()) FrailtySymptom\n where FrailtySymptom.effective.toInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 12 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Has Advanced Illness in Year Before or During Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Advanced Illness in Year Before or During Measurement Period\":\nexists ([Condition: \"Advanced Illness\"] AdvancedIllnessDiagnosis\nwhere AdvancedIllnessDiagnosis.prevalenceInterval() starts during day of Interval[start of \"Measurement Period\" - 1 year, end of \"Measurement Period\"])" + }, + { + "url": "displaySequence", + "valueInteger": 13 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Has Dementia Medications in Year Before or During Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Dementia Medications in Year Before or During Measurement Period\":\n exists (( ([MedicationRequest: medication in \"Dementia Medications\"]).isMedicationActive()) DementiaMedication\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-449\n where DementiaMedication.medicationRequestPeriod() overlaps day of Interval[start of \"Measurement Period\" - 1 year, \n end of \"Measurement Period\"]\n // and DementiaMedication.doNotPerform is not true\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-447\n )" + }, + { + "url": "displaySequence", + "valueInteger": 14 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Is Age 66 or Older with Advanced Illness and Frailty" + }, + { + "url": "statement", + "valueString": "define \"Is Age 66 or Older with Advanced Illness and Frailty\":\n AgeInYearsAt(date from end of \"Measurement Period\")>= 66\n and \"Has Criteria Indicating Frailty\"\n and ( \"Has Advanced Illness in Year Before or During Measurement Period\"\n or \"Has Dementia Medications in Year Before or During Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 15 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Is Age 66 or Older Living Long Term in a Nursing Home" + }, + { + "url": "statement", + "valueString": "define \"Is Age 66 or Older Living Long Term in a Nursing Home\":\n AgeInYearsAt(date from \n end of \"Measurement Period\"\n )>= 66\n and ( ( Last( (([Observation: \"Housing status\"]).isAssessmentPerformed()) HousingStatus \n where HousingStatus.effective.toInterval() ends on or before \n day of end of \"Measurement Period\"\n sort by \n end of effective.toInterval() asc\n )) LastHousingStatus\n where LastHousingStatus.value ~ \"Lives in a nursing home (finding)\"\n ) is not null" + }, + { + "url": "displaySequence", + "valueInteger": 16 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "PalliativeCare" + }, + { + "url": "name", + "valueString": "Has Palliative Care in the Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Palliative Care in the Measurement Period\":\n exists ((([Observation: \"Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)\"]).isAssessmentPerformed()) PalliativeAssessment\n where PalliativeAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ([Condition: \"Palliative Care Diagnosis\"] PalliativeDiagnosis\n where PalliativeDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Palliative Care Encounter\"]).isEncounterPerformed()) PalliativeEncounter\n where PalliativeEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Procedure: \"Palliative Care Intervention\"]).isInterventionPerformed()) PalliativeIntervention\n where PalliativeIntervention.performed.toInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 17 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator Exclusions" + }, + { + "url": "statement", + "valueString": "define \"Denominator Exclusions\":\n Hospice.\"Has Hospice Services\"\n or ( ( exists ( \"Right Mastectomy Diagnosis\" )\n or exists ( \"Right Mastectomy Procedure\" )\n )\n and ( exists ( \"Left Mastectomy Diagnosis\" )\n or exists ( \"Left Mastectomy Procedure\" )\n )\n )\n or exists \"Bilateral Mastectomy Diagnosis\"\n or exists \"Bilateral Mastectomy Procedure\"\n or AIFrailLTCF.\"Is Age 66 or Older with Advanced Illness and Frailty\"\n or AIFrailLTCF.\"Is Age 66 or Older Living Long Term in a Nursing Home\"\n or PalliativeCare.\"Has Palliative Care in the Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 18 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isDiagnosticStudyPerformed" + }, + { + "url": "statement", + "valueString": "//Diagnostic Study, Performed\ndefine fluent function isDiagnosticStudyPerformed(Obs List):\n Obs O\n where O.status in {'final', 'amended', 'corrected' }" + }, + { + "url": "displaySequence", + "valueInteger": 19 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isEncounterPerformed" + }, + { + "url": "statement", + "valueString": "//Encounter, Performed\n//General usage unless required otherwise by measure intent (e.g., follow-up encounters)\ndefine fluent function isEncounterPerformed(Enc List):\n Enc E\n where E.status in {'finished', 'arrived', 'triaged', 'in-progress', 'onleave'}" + }, + { + "url": "displaySequence", + "valueInteger": 20 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "toInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval\n@comment: Normalizes a choice type of DateTime, Quanitty, Interval, or Interval types\nto an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible\nrepresentations for timing-valued elements in QICore, allowing this function to be used across any resource.\nThe input can be provided as a DateTime, Quantity, Interval or Interval.\nThe intent of this function is to provide a clear and concise mechanism to treat single\nelements that have multiple possible representations as intervals so that logic doesn't have to account\nfor the variability. More complex calculations (such as medication request period or dispense period\ncalculation) need specific guidance and consideration. That guidance may make use of this function, but\nthe focus of this function is on single element calculations where the semantics are unambiguous.\nIf the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.\nIf the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,\nand the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.\nIf the input is a DateTime Interval, the result is the input.\nIf the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result\nis a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending\nimmediately before one year later than the date the patient turned the age given as the end of the quantity interval.\nIf the input is a Timing, an error will be thrown indicating that Timing calculations are not implemented. Any other input will reslt in a null DateTime Interval\n*/\ndefine fluent function toInterval(choice Choice, Interval, Timing>):\n case\n\t when choice is DateTime then\n \tInterval[choice as DateTime, choice as DateTime]\n\t\twhen choice is Interval then\n \t\tchoice as Interval\n\t\twhen choice is Quantity then\n\t\t Interval[Patient.birthDate + (choice as Quantity),\n\t\t\t Patient.birthDate + (choice as Quantity) + 1 year)\n\t\twhen choice is Interval then\n\t\t Interval[Patient.birthDate + (choice.low as Quantity),\n\t\t\t Patient.birthDate + (choice.high as Quantity) + 1 year)\n\t\twhen choice is Timing then\n Message(null, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a Timing value is not supported') as Interval\n\t\telse\n\t\t\tnull as Interval\n\tend" + }, + { + "url": "displaySequence", + "valueInteger": 21 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isAssessmentPerformed" + }, + { + "url": "statement", + "valueString": "//This library contains functions that are based on QDM 5.6 to QICore 4.1.1 March 2023 (https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns---QICore-v4.1.1). The functions may appear similar to some QICoreCommon functions but different in that they have constraints that are relevant for measures authored by NCQA.\n\n//Assessment, Performed\ndefine fluent function isAssessmentPerformed(Obs List):\n Obs O\n where O.status in { 'final', 'amended', 'corrected' }\n and exists ( O.category ObservationCategory\n where ( ObservationCategory ) ~ \"survey\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 22 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "FHIRHelpers" + }, + { + "url": "name", + "valueString": "ToConcept" + }, + { + "url": "statement", + "valueString": "/*\n@description: Converts the given FHIR [CodeableConcept](https://hl7.org/fhir/datatypes.html#CodeableConcept) value to a CQL Concept.\n*/\ndefine function ToConcept(concept FHIR.CodeableConcept):\n if concept is null then\n null\n else\n System.Concept {\n codes: concept.coding C return ToCode(C),\n display: concept.text.value\n }" + }, + { + "url": "displaySequence", + "valueInteger": 23 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionOrder" + }, + { + "url": "statement", + "valueString": "//Intervention, Order: active and completed only \ndefine fluent function isInterventionOrder(ServiceRequest List):\n ServiceRequest S\n where S.status in { 'active', 'completed' }\n and S.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 24 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionPerformed" + }, + { + "url": "statement", + "valueString": "//Intervention, Performed\ndefine fluent function isInterventionPerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 25 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "prevalenceInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Returns an interval representing the normalized prevalence period of a given Condition.\n@comment: Uses the ToInterval and ToAbatementInterval functions to determine the widest potential interval from\nonset to abatement as specified in the given Condition. If the condition is active, or has an abatement date the resulting \ninterval will have a closed ending boundary. Otherwise, the resulting interval will have an open ending boundary.\n*/\ndefine fluent function prevalenceInterval(condition Condition):\nif condition.clinicalStatus ~ \"active\"\n or condition.clinicalStatus ~ \"recurrence\"\n or condition.clinicalStatus ~ \"relapse\" then\n Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()]\nelse\n (end of condition.abatementInterval()) abatementDate\n return if abatementDate is null then\n Interval[start of condition.onset.toInterval(), abatementDate)\n else\n Interval[start of condition.onset.toInterval(), abatementDate]" + }, + { + "url": "displaySequence", + "valueInteger": 26 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isProcedurePerformed" + }, + { + "url": "statement", + "valueString": "//Procedure, Performed\ndefine fluent function isProcedurePerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 27 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isDeviceOrder" + }, + { + "url": "statement", + "valueString": "//Device, Order - Personal Use Devices: active and completed only\ndefine fluent function isDeviceOrder(DeviceRequest List):\n DeviceRequest D\n where D.status in { 'active', 'completed' }\n and D.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 28 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "doNotPerform" + }, + { + "url": "statement", + "valueString": "/*\n@description: Returns true if the given DeviceRequest is a negation (i.e. do not perform this order)\n*/\ndefine fluent function doNotPerform(deviceRequest DeviceRequest):\n singleton from (\n deviceRequest.modifierExtension E\n where E.url = 'http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-doNotPerform'\n return E.value as Boolean\n )" + }, + { + "url": "displaySequence", + "valueInteger": 29 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isSymptom" + }, + { + "url": "statement", + "valueString": "//Symptom\ndefine fluent function isSymptom(Obs List):\n Obs O\n where O.status in { 'preliminary', 'final', 'amended', 'corrected' }" + }, + { + "url": "displaySequence", + "valueInteger": 30 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isMedicationActive" + }, + { + "url": "statement", + "valueString": "//Medication, Active\ndefine fluent function isMedicationActive(MedicationRequest List):\n MedicationRequest M\n where M.status = 'active'\n and M.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 31 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CumulativeMedicationDuration" + }, + { + "url": "name", + "valueString": "medicationRequestPeriod" + }, + { + "url": "statement", + "valueString": "define fluent function medicationRequestPeriod(Request \"MedicationRequest\"):\n Request R\n let\n dosage: singleton from R.dosageInstruction,\n doseAndRate: singleton from dosage.doseAndRate,\n timing: dosage.timing,\n frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency),\n period: Quantity(timing.repeat.period, timing.repeat.periodUnit),\n doseRange: doseAndRate.dose,\n doseQuantity: doseAndRate.dose,\n dose: Coalesce(end of doseRange, doseQuantity),\n dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0),\n boundsPeriod: timing.repeat.bounds as Interval,\n daysSupply: (convert R.dispenseRequest.expectedSupplyDuration to days).value,\n quantity: R.dispenseRequest.quantity,\n refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed, 0),\n startDate:\n Coalesce(\n date from start of boundsPeriod,\n date from R.authoredOn,\n date from start of R.dispenseRequest.validityPeriod\n ),\n totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills)\n return\n if startDate is not null and totalDaysSupplied is not null then\n Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ]\n else if startDate is not null and boundsPeriod.\"high\" is not null then\n Interval[startDate, date from end of boundsPeriod]\n else\n null" + }, + { + "url": "displaySequence", + "valueInteger": 32 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CumulativeMedicationDuration" + }, + { + "url": "name", + "valueString": "Quantity" + }, + { + "url": "statement", + "valueString": "/**********************************************************************/\n/* Functions in this region are copied from opioid-mme-r4 */\n/**********************************************************************/\n\ndefine function Quantity(value Decimal, unit String):\n if value is not null then\n System.Quantity { value: value, unit: unit }\n else\n null" + }, + { + "url": "displaySequence", + "valueInteger": 33 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CumulativeMedicationDuration" + }, + { + "url": "name", + "valueString": "ToDaily" + }, + { + "url": "statement", + "valueString": "/*\n Goal is to get to number of days\n Two broad approaches to the calculation:\n 1) Based on supply and frequency, calculate the number of expected days the medication will cover/has covered\n 2) Based on relevant period, determine a covered interval and calculate the length of that interval in days\nThis topic covers several use cases and illustrates how to calculate Cumulative\nMedication Duration for each type of medication resource using the supply and\nfrequency approach.\n*/\n\n/*\n For the first approach, we need to get from frequency to a frequency/day\n So we define ToDaily\n*/\n\n/*\n Calculates daily frequency given frequency within a period\n*/\ndefine function ToDaily(frequency System.Integer, period System.Quantity):\n case period.unit\n when 'h' then frequency * (24.0 / period.value)\n when 'min' then frequency * (24.0 / period.value) * 60\n when 's' then frequency * (24.0 / period.value) * 60 * 60\n when 'd' then frequency * (24.0 / period.value) / 24\n when 'wk' then frequency * (24.0 / period.value) / (24 * 7)\n when 'mo' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */\n when 'a' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */\n when 'hour' then frequency * (24.0 / period.value)\n when 'minute' then frequency * (24.0 / period.value) * 60\n when 'second' then frequency * (24.0 / period.value) * 60 * 60\n when 'day' then frequency * (24.0 / period.value) / 24\n when 'week' then frequency * (24.0 / period.value) / (24 * 7)\n when 'month' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */\n when 'year' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */\n when 'hours' then frequency * (24.0 / period.value)\n when 'minutes' then frequency * (24.0 / period.value) * 60\n when 'seconds' then frequency * (24.0 / period.value) * 60 * 60\n when 'days' then frequency * (24.0 / period.value) / 24\n when 'weeks' then frequency * (24.0 / period.value) / (24 * 7)\n when 'months' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */\n when 'years' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */\n else Message(null, true, 'CMDLogic.ToDaily.UnknownUnit', ErrorLevel, 'Unknown unit ' & period.unit)\n end" + }, + { + "url": "displaySequence", + "valueInteger": 34 + } + ] + } + ], + "name": "EffectiveDataRequirements", + "status": "active", + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "module-definition" + } + ] + }, + "relatedArtifact": [ + { + "type": "depends-on", + "display": "Library Status", + "resource": { + "reference": "Library/Status|1.8.000" + } + }, + { + "type": "depends-on", + "display": "Library QICoreCommon", + "resource": { + "reference": "Library/QICoreCommon|2.1.000" + } + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": { + "reference": "Library/FHIRHelpers|4.4.000" + } + }, + { + "type": "depends-on", + "display": "Library AdultOutpatientEncounters", + "resource": { + "reference": "Library/AdultOutpatientEncounters|4.11.000" + } + }, + { + "type": "depends-on", + "display": "Library Hospice", + "resource": { + "reference": "Library/Hospice|6.12.000" + } + }, + { + "type": "depends-on", + "display": "Library AIFrailLTCF", + "resource": { + "reference": "Library/AdvancedIllnessandFrailty|1.16.000" + } + }, + { + "type": "depends-on", + "display": "Library CMD", + "resource": { + "reference": "Library/CumulativeMedicationDuration|4.1.000" + } + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": { + "reference": "Library/PalliativeCare|1.11.000" + } + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": { + "reference": "http://snomed.info/sct" + } + }, + { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": { + "reference": "http://terminology.hl7.org/CodeSystem/observation-category" + } + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": { + "reference": "http://loinc.org" + } + }, + { + "type": "depends-on", + "display": "Value set Mammography", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" + } + }, + { + "type": "depends-on", + "display": "Value set Office Visit", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + }, + { + "type": "depends-on", + "display": "Value set Annual Wellness Visit", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + } + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Established Office Visit, 18 and Up", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Initial Office Visit, 18 and Up", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + }, + { + "type": "depends-on", + "display": "Value set Home Healthcare Services", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + }, + { + "type": "depends-on", + "display": "Value set Virtual Encounter", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + }, + { + "type": "depends-on", + "display": "Value set Telephone Visits", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + }, + { + "type": "depends-on", + "display": "Value set Encounter Inpatient", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + }, + { + "type": "depends-on", + "display": "Value set Hospice Encounter", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + }, + { + "type": "depends-on", + "display": "Value set Hospice Care Ambulatory", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + }, + { + "type": "depends-on", + "display": "Value set Hospice Diagnosis", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + }, + { + "type": "depends-on", + "display": "Value set Status Post Right Mastectomy", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + } + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy, Unspecified Laterality", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + } + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Right", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + } + }, + { + "type": "depends-on", + "display": "Value set Status Post Left Mastectomy", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + } + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Left", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + } + }, + { + "type": "depends-on", + "display": "Value set History of bilateral mastectomy", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" + } + }, + { + "type": "depends-on", + "display": "Value set Bilateral Mastectomy", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" + } + }, + { + "type": "depends-on", + "display": "Value set Frailty Device", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + }, + { + "type": "depends-on", + "display": "Value set Frailty Diagnosis", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1074" + } + }, + { + "type": "depends-on", + "display": "Value set Frailty Encounter", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1088" + } + }, + { + "type": "depends-on", + "display": "Value set Frailty Symptom", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1075" + } + }, + { + "type": "depends-on", + "display": "Value set Advanced Illness", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1082" + } + }, + { + "type": "depends-on", + "display": "Value set Dementia Medications", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.196.12.1510" + } + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Diagnosis", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Encounter", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Intervention", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "ErrorLevel", + "use": "in", + "min": 0, + "max": "1", + "type": "string" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + } + ], + "dataRequirement": [ + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ], + "valueSetReference": {} + }, + { + "path": "value", + "valueSetReference": {} + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "98181-1", + "display": "Medical equipment used" + } + ], + "valueSetReference": {} + }, + { + "path": "value", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + } + ], + "dateFilter": [ + { + "path": "effective", + "valuePeriod": { + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expression", + "valueExpression": { + "language": "text/cql-identifier", + "expression": "Measurement Period" + } + } + ] + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1075" + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ], + "valueSetReference": {} + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ], + "valueSetReference": {} + }, + { + "path": "value", + "valueSetReference": {} + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ], + "valueSetReference": {} + } + ] + }, + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1088" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + } + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + } + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" + } + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code", "bodySite"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1074" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1082" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + } + ] + }, + { + "type": "DeviceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-devicerequest" + ], + "mustSupport": [ + "code", + "status", + "status.value", + "intent", + "intent.value", + "url", + "url.value", + "value", + "authoredOn", + "authoredOn.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + } + ] + }, + { + "type": "MedicationRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-medicationrequest" + ], + "mustSupport": [ + "medication", + "status", + "status.value", + "intent", + "intent.value", + "dosageInstruction", + "dispenseRequest", + "dispenseRequest.expectedSupplyDuration", + "dispenseRequest.quantity", + "dispenseRequest.numberOfRepeatsAllowed", + "dispenseRequest.numberOfRepeatsAllowed.value", + "authoredOn", + "authoredOn.value", + "dispenseRequest.validityPeriod" + ], + "codeFilter": [ + { + "path": "medication", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.196.12.1510" + } + } + ] + } + ] + } + ], + "extension": [ + { + "id": "effective-data-requirements", + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-effectiveDataRequirements", + "valueReference": { + "reference": "#effective-data-requirements" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } + ], + "url": "https://madie.cms.gov/Measure/BreastCancerScreeningFHIR", + "identifier": [ + { + "use": "usual", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "short-name" + } + ] + }, + "system": "https://madie.cms.gov/measure/shortName", + "value": "CMS125FHIR" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-independent" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:f766afa2-f780-45d2-b224-c1bdb733fa6f" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-specific" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:7c89bd23-97eb-446b-b63a-975b63503b1c" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "publisher" + } + ] + }, + "system": "https://madie.cms.gov/measure/cmsId", + "value": "125FHIR", + "assigner": { + "display": "CMS" + } + } + ], + "version": "0.0.001", + "name": "BreastCancerScreeningFHIR", + "title": "Breast Cancer ScreeningFHIR", + "status": "active", + "experimental": false, + "date": "2024-07-09T14:53:55+00:00", + "publisher": "National Committee for Quality Assurance", + "contact": [ + { + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "description": "Percentage of women 50-74 years of age who had a mammogram to screen for breast cancer in the 27 months prior to the end of the Measurement Period", + "purpose": "UNKNOWN", + "usage": "This measure evaluates primary screening. Do not count biopsies, breast ultrasounds, or MRIs because they are not appropriate methods for primary breast cancer screening. Please note the measure may include screenings performed outside the age range of patients referenced in the initial population. Screenings that occur prior to the measurement period are valid to meet measure criteria. This eCQM is a patient-based measure. This FHIR-based measure has been derived from the QDM-based measure: CMS125v13. Please refer to the HL7 QI-Core Implementation Guide (http://hl7.org/fhir/us/qicore/STU4.1.1/) for more information on QI-Core and mapping recommendations from QDM to QI-Core 4.1.1 (http://hl7.org/fhir/us/qicore/STU4.1.1/qdm-to-qicore.html).", + "copyright": "This Physician Performance Measure (Measure) and related data specifications are owned and were developed by the National Committee for Quality Assurance (NCQA). NCQA is not responsible for any use of the Measure. NCQA makes no representations, warranties, or endorsement about the quality of any organization or physician that uses or reports performance measures and NCQA has no liability to anyone who relies on such measures or specifications. NCQA holds a copyright in the Measure. The Measure can be reproduced and distributed, without modification, for noncommercial purposes (e.g., use by healthcare providers in connection with their practices) without obtaining approval from NCQA. Commercial use is defined as the sale, licensing, or distribution of the Measure for commercial gain, or incorporation of the Measure into a product or service that is sold, licensed or distributed for commercial gain. All commercial uses or requests for modification must be approved by NCQA and are subject to a license at the discretion of NCQA. (C) 2012-2024 National Committee for Quality Assurance. All Rights Reserved. Limited proprietary coding is contained in the Measure specifications for user convenience. Users of proprietary code sets should obtain all necessary licenses from the owners of the code sets. NCQA disclaims all liability for use or accuracy of any third-party codes contained in the specifications. CPT(R) codes, descriptions and other data are copyright 2024. American Medical Association. All rights reserved. CPT is a trademark of the American Medical Association. Fee schedules, relative value units, conversion factors and/or related components are not assigned by the AMA, are not part of CPT, and the AMA is not recommending their use. The AMA does not directly or indirectly practice medicine or dispense medical services. The AMA assumes no liability for data contained or not contained herein. Applicable FARS/DFARS restrictions apply to government use. Some measure specifications contain coding from LOINC(R) (http://loinc.org). The LOINC table, LOINC codes, LOINC panels and form file, LOINC linguistic variants file, LOINC/RSNA Radiology Playbook, and LOINC/IEEE Medical Device Code Mapping Table are copyright 2004-2024 Regenstrief Institute, Inc. and the Logical Observation Identifiers Names and Codes (LOINC) Committee, and are available at no cost under the license at http://loinc.org/terms-of-use. This material contains SNOMED Clinical Terms(R) (SNOMED CT[R]) copyright 2004-2023 International Health Terminology Standards Development Organisation. ICD-10 copyright 2024 World Health Organization. All Rights Reserved. Some measures use RxNorm, a standardized nomenclature and coding for clinical drugs and drug delivery devices, which is made publicly available courtesy of the U.S. National Library of Medicine (NLM), National Institutes of Health, Department of Health and Human Services. NLM is not responsible for the measures and does not endorse or recommend this or any other product. “HL7” is the registered trademark of Health Level Seven International.", + "effectivePeriod": { + "start": "2025-01-01", + "end": "2025-12-31" + }, + "author": [ + { + "name": "National Committee for Quality Assurance", + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "library": [ + { + "reference": "https://madie.cms.gov/Library/BreastCancerScreeningFHIR" + } + ], + "disclaimer": "The performance Measure is not a clinical guideline and does not establish a standard of medical care, and has not been tested for all potential applications. THE MEASURE AND SPECIFICATIONS ARE PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. Due to technical limitations, registered trademarks are indicated by (R) or [R] and unregistered trademarks are indicated by (TM) or [TM].", + "rationale": "Breast cancer is one of the most common types of cancers, accounting for 15 percent of all new cancer diagnoses in the U.S. (Noone et al., 2018). In 2015, over 3 million women were estimated to be living with breast cancer in the U.S. and it is estimated that 12 percent of women will be diagnosed with breast cancer at some point during their lifetime (Noone et al., 2018). While there are other factors that affect a woman's risk of developing breast cancer, advancing age is a primary risk factor. Breast cancer is most frequently diagnosed among women ages 55-64; the median age at diagnosis is 62 years (Noone et al., 2018). The chance of a woman being diagnosed with breast cancer in a given year increases with age. By age 40, the chances are 1 in 68; by age 50 it becomes 1 in 43; by age 60, it is 1 in 29 (American Cancer Society, 2017).", + "clinicalRecommendationStatement": "The U.S. Preventive Services Task Force (USPSTF) recommends biennial screening mammography for women aged 50-74 years (B recommendation) (USPSTF, 2016). The decision to start screening mammography in women prior to age 50 years should be an individual one. Women who place a higher value on the potential benefit than the potential harms may choose to begin biennial screening between the ages of 40 and 49 years (C recommendation) (USPSTF, 2016). The USPSTF concludes that the current evidence is insufficient to assess the balance of benefits and harms of screening mammography in women aged 75 years or older (I statement) (USPSTF, 2016). The USPSTF concludes that the current evidence is insufficient to assess the benefits and harms of digital breast tomosynthesis (DBT) as a primary screening method for breast cancer (I statement) (USPSTF, 2016). The USPSTF concludes that the current evidence is insufficient to assess the balance of benefits and harms of adjunctive screening for breast cancer using breast ultrasonography, magnetic resonance imaging, DBT, or other methods in women identified to have dense breasts on an otherwise negative screening mammogram (I statement) (USPSTF, 2016). The National Comprehensive Cancer Network (NCCN) and the American College of Radiology (ACR) recommend using conventional mammography or DBT for screening women at low, intermediate or high risk for breast cancer (NCCN, 2021) (ACR, 2017).", + "group": [ + { + "id": "64e646302ad653247b573ada", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-scoring", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-scoring", + "code": "proportion", + "display": "Proportion" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-populationBasis", + "valueCode": "boolean" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-type", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-type", + "code": "process", + "display": "Process" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-rateAggregation", + "valueCode": "None" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-improvementNotation", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-improvement-notation", + "code": "decrease", + "display": "increase" + } + ] + } + } + ], + "population": [ + { + "id": "FC061B94-3EB0-46E6-AD30-370E47E648AD", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "initial-population", + "display": "Initial Population" + } + ] + }, + "description": "Women 52-74 years of age by the end of the measurement period with a visit during the measurement period", + "criteria": { + "language": "text/cql-identifier", + "expression": "Initial Population" + } + }, + { + "id": "054B4403-E6CF-4F3C-B36B-12003F3BA268", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator", + "display": "Denominator" + } + ] + }, + "description": "Equals Initial Population", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator" + } + }, + { + "id": "209265B9-B25B-4809-BB65-DFD42207CB9D", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator-exclusion", + "display": "Denominator Exclusion" + } + ] + }, + "description": "Exclude patients who are in hospice care for any part of the measurement period. Women who had a bilateral mastectomy or who have a history of a bilateral mastectomy or for whom there is evidence of a right and a left unilateral mastectomy on or before the end of the measurement period. Exclude patients 66 and older by the end of the measurement period with an indication of frailty for any part of the measurement period who also meet any of the following advanced illness criteria: - Advanced illness diagnosis during the measurement period or the year prior - OR taking dementia medications during the measurement period or the year prior Exclude patients 66 and older by the end of the measurement period who are living long term in a nursing home any time on or before the end of the measurement period. Exclude patients receiving palliative care for any part of the measurement period.", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator Exclusions" + } + }, + { + "id": "B7745FD9-0697-40A0-A179-3056DD614C8F", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "numerator", + "display": "Numerator" + } + ] + }, + "description": "Women with one or more mammograms any time on or between October 1 two years prior to the measurement period and the end of the measurement period", + "criteria": { + "language": "text/cql-identifier", + "expression": "Numerator" + } + } + ] + } + ] + }, + "request": { + "method": "PUT", + "url": "Measure/BreastCancerScreeningFHIR" + } + }, + { + "fullUrl": "https://madie.cms.gov/Library/BreastCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Library", + "id": "BreastCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-library-cqfm" + ] + }, + "language": "en", + "contained": [ + { + "resourceType": "Parameters", + "id": "options", + "parameter": [ + { + "name": "translatorVersion", + "valueString": "3.10.0" + }, + { + "name": "option", + "valueString": "EnableAnnotations" + }, + { + "name": "option", + "valueString": "EnableLocators" + }, + { + "name": "option", + "valueString": "DisableListDemotion" + }, + { + "name": "option", + "valueString": "DisableListPromotion" + }, + { + "name": "format", + "valueString": "XML" + }, + { + "name": "format", + "valueString": "JSON" + }, + { + "name": "analyzeDataRequirements", + "valueBoolean": true + }, + { + "name": "collapseDataRequirements", + "valueBoolean": true + }, + { + "name": "compatibilityLevel", + "valueString": "1.5" + }, + { + "name": "enableCqlOnly", + "valueBoolean": false + }, + { + "name": "errorLevel", + "valueString": "Info" + }, + { + "name": "signatureLevel", + "valueString": "None" + }, + { + "name": "validateUnits", + "valueBoolean": true + }, + { + "name": "verifyOnly", + "valueBoolean": false + } + ] + } + ], + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender", + "code": "F", + "display": "Female" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "7771000", + "display": "Left (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "24028007", + "display": "Right (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlOptions", + "valueReference": { + "reference": "#options" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } + ], + "url": "https://madie.cms.gov/Library/BreastCancerScreeningFHIR", + "identifier": [ + { + "use": "official", + "system": "https://madie.cms.gov/login", + "value": "BreastCancerScreeningFHIR" + } + ], + "version": "0.0.001", + "name": "BreastCancerScreeningFHIR", + "title": "BreastCancerScreeningFHIR", + "status": "active", + "experimental": false, + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } + ] + }, + "date": "2024-05-16T15:11:55+00:00", + "description": "BreastCancerScreeningFHIR", + "relatedArtifact": [ + { + "type": "depends-on", + "display": "QICore model information", + "resource": { + "reference": "http://hl7.org/fhir/Library/QICore-ModelInfo" + } + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": { + "reference": "http://ecqi.healthit.gov/ecqms/Library/FHIRHelpers|4.4.000" + } + }, + { + "type": "depends-on", + "display": "Library SDE", + "resource": { + "reference": "http://ecqi.healthit.gov/ecqms/Library/SupplementalDataElements|3.5.000" + } + }, + { + "type": "depends-on", + "display": "Library QICoreCommon", + "resource": { + "reference": "http://ecqi.healthit.gov/ecqms/Library/QICoreCommon|2.1.000" + } + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": { + "reference": "http://ecqi.healthit.gov/ecqms/Library/PalliativeCare|1.11.000" + } + }, + { + "type": "depends-on", + "display": "Code system AdministrativeGender", + "resource": { + "reference": "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender" + } + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": { + "reference": "http://snomed.info/sct" + } + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": { + "reference": "http://loinc.org" + } + }, + { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": { + "reference": "http://terminology.hl7.org/CodeSystem/observation-category" + } + }, + { + "type": "depends-on", + "display": "Value set Status Post Left Mastectomy", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + } + }, + { + "type": "depends-on", + "display": "Value set Status Post Right Mastectomy", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + } + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Left", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + } + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Right", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + } + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy, Unspecified Laterality", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + } + }, + { + "type": "depends-on", + "display": "Value set Payer Type", + "resource": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "ErrorLevel", + "use": "in", + "min": 0, + "max": "1", + "type": "string" + }, + { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Right Mastectomy Diagnosis", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Right Mastectomy Procedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Left Mastectomy Diagnosis", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Left Mastectomy Procedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Bilateral Mastectomy Diagnosis", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Bilateral Mastectomy Procedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "October 1 Two Years Prior to the Measurement Period", + "use": "out", + "min": 0, + "max": "1", + "type": "dateTime" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "SDE Ethnicity", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Payer", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "SDE Race", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Sex", + "use": "out", + "min": 0, + "max": "1", + "type": "Coding" + } + ], + "dataRequirement": [ + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ], + "mustSupport": ["ethnicity", "race"] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1088" + } + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code", "bodySite"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1074" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1082" + } + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + } + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + } + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" + } + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ], + "valueSetReference": {} + }, + { + "path": "value", + "valueSetReference": {} + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "98181-1", + "display": "Medical equipment used" + } + ], + "valueSetReference": {} + }, + { + "path": "value", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + } + ], + "dateFilter": [ + { + "path": "effective", + "valuePeriod": { + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expression", + "valueExpression": { + "language": "text/cql-identifier", + "expression": "Measurement Period" + } + } + ] + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1075" + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ], + "valueSetReference": {} + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ], + "valueSetReference": {} + }, + { + "path": "value", + "valueSetReference": {} + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ], + "valueSetReference": {} + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" + } + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + } + ] + }, + { + "type": "DeviceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-devicerequest" + ], + "mustSupport": [ + "code", + "status", + "status.value", + "intent", + "intent.value", + "url", + "url.value", + "value", + "authoredOn", + "authoredOn.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + } + ] + }, + { + "type": "MedicationRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-medicationrequest" + ], + "mustSupport": [ + "medication", + "status", + "status.value", + "intent", + "intent.value", + "dosageInstruction", + "dispenseRequest", + "dispenseRequest.expectedSupplyDuration", + "dispenseRequest.quantity", + "dispenseRequest.numberOfRepeatsAllowed", + "dispenseRequest.numberOfRepeatsAllowed.value", + "authoredOn", + "authoredOn.value", + "dispenseRequest.validityPeriod" + ], + "codeFilter": [ + { + "path": "medication", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.196.12.1510" + } + } + ] + }, + { + "type": "Coverage", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-coverage" + ], + "mustSupport": ["type", "period"], + "codeFilter": [ + { + "path": "type", + "valueSetReference": { + "reference": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + } + ] + } + ], + "content": [ + { + "contentType": "text/cql", + "data": "bGlicmFyeSBCcmVhc3RDYW5jZXJTY3JlZW5pbmdGSElSIHZlcnNpb24gJzAuMC4wMDEnDQoNCnVzaW5nIFFJQ29yZSB2ZXJzaW9uICc0LjEuMScNCg0KaW5jbHVkZSBGSElSSGVscGVycyB2ZXJzaW9uICc0LjQuMDAwJyBjYWxsZWQgRkhJUkhlbHBlcnMNCmluY2x1ZGUgU3VwcGxlbWVudGFsRGF0YUVsZW1lbnRzIHZlcnNpb24gJzMuNS4wMDAnIGNhbGxlZCBTREUNCmluY2x1ZGUgUUlDb3JlQ29tbW9uIHZlcnNpb24gJzIuMS4wMDAnIGNhbGxlZCBRSUNvcmVDb21tb24NCmluY2x1ZGUgQWR1bHRPdXRwYXRpZW50RW5jb3VudGVycyB2ZXJzaW9uICc0LjExLjAwMCcgY2FsbGVkIEFkdWx0T3V0cGF0aWVudEVuY291bnRlcnMNCmluY2x1ZGUgSG9zcGljZSB2ZXJzaW9uICc2LjEyLjAwMCcgY2FsbGVkIEhvc3BpY2UNCmluY2x1ZGUgU3RhdHVzIHZlcnNpb24gJzEuOC4wMDAnIGNhbGxlZCBTdGF0dXMNCmluY2x1ZGUgUGFsbGlhdGl2ZUNhcmUgdmVyc2lvbiAnMS4xMS4wMDAnIGNhbGxlZCBQYWxsaWF0aXZlQ2FyZQ0KaW5jbHVkZSBBZHZhbmNlZElsbG5lc3NhbmRGcmFpbHR5IHZlcnNpb24gJzEuMTYuMDAwJyBjYWxsZWQgQUlGcmFpbExUQ0YNCg0KY29kZXN5c3RlbSAiQWRtaW5pc3RyYXRpdmVHZW5kZXIiOiAnaHR0cDovL3Rlcm1pbm9sb2d5LmhsNy5vcmcvQ29kZVN5c3RlbS92My1BZG1pbmlzdHJhdGl2ZUdlbmRlcicNCmNvZGVzeXN0ZW0gIlNOT01FRENUIjogJ2h0dHA6Ly9zbm9tZWQuaW5mby9zY3QnDQpjb2Rlc3lzdGVtICJMT0lOQyI6ICdodHRwOi8vbG9pbmMub3JnJw0KDQp2YWx1ZXNldCAiQmlsYXRlcmFsIE1hc3RlY3RvbXkiOiAnaHR0cDovL2N0cy5ubG0ubmloLmdvdi9maGlyL1ZhbHVlU2V0LzIuMTYuODQwLjEuMTEzODgzLjMuNDY0LjEwMDMuMTk4LjEyLjEwMDUnDQp2YWx1ZXNldCAiSGlzdG9yeSBvZiBiaWxhdGVyYWwgbWFzdGVjdG9teSI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTM4ODMuMy40NjQuMTAwMy4xOTguMTIuMTA2OCcNCnZhbHVlc2V0ICJNYW1tb2dyYXBoeSI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTM4ODMuMy40NjQuMTAwMy4xMDguMTIuMTAxOCcNCnZhbHVlc2V0ICJTdGF0dXMgUG9zdCBMZWZ0IE1hc3RlY3RvbXkiOiAnaHR0cDovL2N0cy5ubG0ubmloLmdvdi9maGlyL1ZhbHVlU2V0LzIuMTYuODQwLjEuMTEzODgzLjMuNDY0LjEwMDMuMTk4LjEyLjEwNjknDQp2YWx1ZXNldCAiU3RhdHVzIFBvc3QgUmlnaHQgTWFzdGVjdG9teSI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTM4ODMuMy40NjQuMTAwMy4xOTguMTIuMTA3MCcNCnZhbHVlc2V0ICJVbmlsYXRlcmFsIE1hc3RlY3RvbXkgTGVmdCI6ICdodHRwOi8vY3RzLm5sbS5uaWguZ292L2ZoaXIvVmFsdWVTZXQvMi4xNi44NDAuMS4xMTM4ODMuMy40NjQuMTAwMy4xOTguMTIuMTEzMycNCnZhbHVlc2V0ICJVbmlsYXRlcmFsIE1hc3RlY3RvbXkgUmlnaHQiOiAnaHR0cDovL2N0cy5ubG0ubmloLmdvdi9maGlyL1ZhbHVlU2V0LzIuMTYuODQwLjEuMTEzODgzLjMuNDY0LjEwMDMuMTk4LjEyLjExMzQnDQp2YWx1ZXNldCAiVW5pbGF0ZXJhbCBNYXN0ZWN0b215LCBVbnNwZWNpZmllZCBMYXRlcmFsaXR5IjogJ2h0dHA6Ly9jdHMubmxtLm5paC5nb3YvZmhpci9WYWx1ZVNldC8yLjE2Ljg0MC4xLjExMzg4My4zLjQ2NC4xMDAzLjE5OC4xMi4xMDcxJw0KDQpjb2RlICJGZW1hbGUiOiAnRicgZnJvbSAiQWRtaW5pc3RyYXRpdmVHZW5kZXIiIGRpc3BsYXkgJ0ZlbWFsZScNCmNvZGUgIkxlZnQgKHF1YWxpZmllciB2YWx1ZSkiOiAnNzc3MTAwMCcgZnJvbSAiU05PTUVEQ1QiIGRpc3BsYXkgJ0xlZnQgKHF1YWxpZmllciB2YWx1ZSknDQpjb2RlICJSaWdodCAocXVhbGlmaWVyIHZhbHVlKSI6ICcyNDAyODAwNycgZnJvbSAiU05PTUVEQ1QiIGRpc3BsYXkgJ1JpZ2h0IChxdWFsaWZpZXIgdmFsdWUpJw0KDQpwYXJhbWV0ZXIgIk1lYXN1cmVtZW50IFBlcmlvZCIgSW50ZXJ2YWw8RGF0ZVRpbWU+DQoNCmNvbnRleHQgUGF0aWVudA0KDQpkZWZpbmUgIkluaXRpYWwgUG9wdWxhdGlvbiI6DQogIEFnZUluWWVhcnNBdChkYXRlIGZyb20gDQogICAgZW5kIG9mICJNZWFzdXJlbWVudCBQZXJpb2QiDQogICkgaW4gSW50ZXJ2YWxbNTIsIDc0XQ0KICAgIGFuZCBQYXRpZW50LmdlbmRlciA9ICdmZW1hbGUnDQogICAgYW5kIGV4aXN0cyBBZHVsdE91dHBhdGllbnRFbmNvdW50ZXJzLiJRdWFsaWZ5aW5nIEVuY291bnRlcnMiDQoNCmRlZmluZSAiRGVub21pbmF0b3IiOg0KICAiSW5pdGlhbCBQb3B1bGF0aW9uIg0KDQpkZWZpbmUgIkRlbm9taW5hdG9yIEV4Y2x1c2lvbnMiOg0KICBIb3NwaWNlLiJIYXMgSG9zcGljZSBTZXJ2aWNlcyINCiAgICBvciAoICggZXhpc3RzICggIlJpZ2h0IE1hc3RlY3RvbXkgRGlhZ25vc2lzIiApDQogICAgICAgICAgb3IgZXhpc3RzICggIlJpZ2h0IE1hc3RlY3RvbXkgUHJvY2VkdXJlIiApDQogICAgICApDQogICAgICAgIGFuZCAoIGV4aXN0cyAoICJMZWZ0IE1hc3RlY3RvbXkgRGlhZ25vc2lzIiApDQogICAgICAgICAgICBvciBleGlzdHMgKCAiTGVmdCBNYXN0ZWN0b215IFByb2NlZHVyZSIgKQ0KICAgICAgICApDQogICAgKQ0KICAgIG9yIGV4aXN0cyAiQmlsYXRlcmFsIE1hc3RlY3RvbXkgRGlhZ25vc2lzIg0KICAgIG9yIGV4aXN0cyAiQmlsYXRlcmFsIE1hc3RlY3RvbXkgUHJvY2VkdXJlIg0KICAgIG9yIEFJRnJhaWxMVENGLiJJcyBBZ2UgNjYgb3IgT2xkZXIgd2l0aCBBZHZhbmNlZCBJbGxuZXNzIGFuZCBGcmFpbHR5Ig0KICAgIG9yIEFJRnJhaWxMVENGLiJJcyBBZ2UgNjYgb3IgT2xkZXIgTGl2aW5nIExvbmcgVGVybSBpbiBhIE51cnNpbmcgSG9tZSINCiAgICBvciBQYWxsaWF0aXZlQ2FyZS4iSGFzIFBhbGxpYXRpdmUgQ2FyZSBpbiB0aGUgTWVhc3VyZW1lbnQgUGVyaW9kIg0KDQpkZWZpbmUgIlJpZ2h0IE1hc3RlY3RvbXkgRGlhZ25vc2lzIjoNCiAgKCBbQ29uZGl0aW9uOiAiU3RhdHVzIFBvc3QgUmlnaHQgTWFzdGVjdG9teSJdIFJpZ2h0TWFzdGVjdG9teVByb2NlZHVyZQ0KICAgIHVuaW9uICggW0NvbmRpdGlvbjogIlVuaWxhdGVyYWwgTWFzdGVjdG9teSwgVW5zcGVjaWZpZWQgTGF0ZXJhbGl0eSJdIFVuaWxhdGVyYWxNYXN0ZWN0b215RGlhZ25vc2lzDQogICAgICAgIHdoZXJlIGV4aXN0cyAoIFVuaWxhdGVyYWxNYXN0ZWN0b215RGlhZ25vc2lzLmJvZHlTaXRlIFMNCiAgICAgICAgICAgIHdoZXJlIFMgfiAiUmlnaHQgKHF1YWxpZmllciB2YWx1ZSkiDQogICAgICAgICkNCiAgICApICkgUmlnaHRNYXN0ZWN0b215DQogICAgd2hlcmUgUmlnaHRNYXN0ZWN0b215LnByZXZhbGVuY2VJbnRlcnZhbCAoICkgc3RhcnRzIG9uIG9yIGJlZm9yZSBlbmQgb2YgIk1lYXN1cmVtZW50IFBlcmlvZCINCg0KZGVmaW5lICJSaWdodCBNYXN0ZWN0b215IFByb2NlZHVyZSI6DQogICggKCBbUHJvY2VkdXJlOiAiVW5pbGF0ZXJhbCBNYXN0ZWN0b215IFJpZ2h0Il0gKS5pc1Byb2NlZHVyZVBlcmZvcm1lZCAoICkgKSBVbmlsYXRlcmFsTWFzdGVjdG9teVJpZ2h0UGVyZm9ybWVkDQogICAgd2hlcmUgVW5pbGF0ZXJhbE1hc3RlY3RvbXlSaWdodFBlcmZvcm1lZC5wZXJmb3JtZWQudG9JbnRlcnZhbCAoICkgZW5kcyBvbiBvciBiZWZvcmUgZW5kIG9mICJNZWFzdXJlbWVudCBQZXJpb2QiDQoNCmRlZmluZSAiTGVmdCBNYXN0ZWN0b215IERpYWdub3NpcyI6DQogICggW0NvbmRpdGlvbjogIlN0YXR1cyBQb3N0IExlZnQgTWFzdGVjdG9teSJdDQogICAgdW5pb24gKCBbQ29uZGl0aW9uOiAiVW5pbGF0ZXJhbCBNYXN0ZWN0b215LCBVbnNwZWNpZmllZCBMYXRlcmFsaXR5Il0gVW5pbGF0ZXJhbE1hc3RlY3RvbXlEaWFnbm9zaXMNCiAgICAgICAgd2hlcmUgZXhpc3RzICggVW5pbGF0ZXJhbE1hc3RlY3RvbXlEaWFnbm9zaXMuYm9keVNpdGUgUw0KICAgICAgICAgICAgd2hlcmUgUyB+ICJMZWZ0IChxdWFsaWZpZXIgdmFsdWUpIg0KICAgICAgICApDQogICAgKSApIExlZnRNYXN0ZWN0b215DQogICAgd2hlcmUgTGVmdE1hc3RlY3RvbXkucHJldmFsZW5jZUludGVydmFsICggKSBzdGFydHMgb24gb3IgYmVmb3JlIGVuZCBvZiAiTWVhc3VyZW1lbnQgUGVyaW9kIg0KDQpkZWZpbmUgIkxlZnQgTWFzdGVjdG9teSBQcm9jZWR1cmUiOg0KICAoICggW1Byb2NlZHVyZTogIlVuaWxhdGVyYWwgTWFzdGVjdG9teSBMZWZ0Il0gKS5pc1Byb2NlZHVyZVBlcmZvcm1lZCAoICkgKSBVbmlsYXRlcmFsTWFzdGVjdG9teUxlZnRQZXJmb3JtZWQNCiAgICB3aGVyZSBVbmlsYXRlcmFsTWFzdGVjdG9teUxlZnRQZXJmb3JtZWQucGVyZm9ybWVkLnRvSW50ZXJ2YWwgKCApIGVuZHMgb24gb3IgYmVmb3JlIGVuZCBvZiAiTWVhc3VyZW1lbnQgUGVyaW9kIg0KDQpkZWZpbmUgIkJpbGF0ZXJhbCBNYXN0ZWN0b215IERpYWdub3NpcyI6DQogIFtDb25kaXRpb246ICJIaXN0b3J5IG9mIGJpbGF0ZXJhbCBtYXN0ZWN0b215Il0gQmlsYXRlcmFsTWFzdGVjdG9teUhpc3RvcnkNCiAgICB3aGVyZSBCaWxhdGVyYWxNYXN0ZWN0b215SGlzdG9yeS5wcmV2YWxlbmNlSW50ZXJ2YWwgKCApIHN0YXJ0cyBvbiBvciBiZWZvcmUgZW5kIG9mICJNZWFzdXJlbWVudCBQZXJpb2QiDQoNCmRlZmluZSAiQmlsYXRlcmFsIE1hc3RlY3RvbXkgUHJvY2VkdXJlIjoNCiAgKCAoIFtQcm9jZWR1cmU6ICJCaWxhdGVyYWwgTWFzdGVjdG9teSJdICkuaXNQcm9jZWR1cmVQZXJmb3JtZWQgKCApICkgQmlsYXRlcmFsTWFzdGVjdG9teVBlcmZvcm1lZA0KICAgIHdoZXJlIEJpbGF0ZXJhbE1hc3RlY3RvbXlQZXJmb3JtZWQucGVyZm9ybWVkLnRvSW50ZXJ2YWwgKCApIGVuZHMgb24gb3IgYmVmb3JlIGVuZCBvZiAiTWVhc3VyZW1lbnQgUGVyaW9kIg0KDQpkZWZpbmUgIk51bWVyYXRvciI6DQogIGV4aXN0cyAoICggKCBbT2JzZXJ2YXRpb246ICJNYW1tb2dyYXBoeSJdICkuaXNEaWFnbm9zdGljU3R1ZHlQZXJmb3JtZWQgKCApICkgTWFtbW9ncmFtDQogICAgICB3aGVyZSBNYW1tb2dyYW0uZWZmZWN0aXZlLnRvSW50ZXJ2YWwgKCApIGVuZHMgZHVyaW5nIGRheSBvZiBJbnRlcnZhbFsiT2N0b2JlciAxIFR3byBZZWFycyBQcmlvciB0byB0aGUgTWVhc3VyZW1lbnQgUGVyaW9kIiwgZW5kIG9mICJNZWFzdXJlbWVudCBQZXJpb2QiXQ0KICApDQoNCmRlZmluZSAiT2N0b2JlciAxIFR3byBZZWFycyBQcmlvciB0byB0aGUgTWVhc3VyZW1lbnQgUGVyaW9kIjoNCiAgRGF0ZVRpbWUoKHllYXIgZnJvbSBzdGFydCBvZiAiTWVhc3VyZW1lbnQgUGVyaW9kIiAtIDIpLCAxMCwgMSwgMCwgMCwgMCwgMCwgMCkNCg0KZGVmaW5lICJTREUgRXRobmljaXR5IjoNCiAgU0RFLiJTREUgRXRobmljaXR5Ig0KDQpkZWZpbmUgIlNERSBQYXllciI6DQogIFNERS4iU0RFIFBheWVyIg0KDQpkZWZpbmUgIlNERSBSYWNlIjoNCiAgU0RFLiJTREUgUmFjZSINCg0KZGVmaW5lICJTREUgU2V4IjoNCiAgU0RFLiJTREUgU2V4Ig==" + }, + { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1" localId="0">
   <annotation translatorVersion="3.10.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" signatureLevel="None" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:s r="491">
         <a:s>library BreastCancerScreeningFHIR version '0.0.001'</a:s>
      </a:s>
   </annotation>
   <identifier id="BreastCancerScreeningFHIR" system="http://ecqi.healthit.gov/ecqms" version="0.0.001"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localId="1" localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="206" locator="3:1-3:28" localIdentifier="QICore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="206">
               <a:s>using </a:s>
               <a:s>
                  <a:s>QICore</a:s>
               </a:s>
               <a:s> version '4.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="207" locator="5:1-5:56" localIdentifier="FHIRHelpers" path="http://ecqi.healthit.gov/ecqms/FHIRHelpers" version="4.4.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="207">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.4.000' called FHIRHelpers</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="208" locator="6:1-6:61" localIdentifier="SDE" path="http://ecqi.healthit.gov/ecqms/SupplementalDataElements" version="3.5.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="208">
               <a:s>include </a:s>
               <a:s>
                  <a:s>SupplementalDataElements</a:s>
               </a:s>
               <a:s> version '3.5.000' called SDE</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="209" locator="7:1-7:58" localIdentifier="QICoreCommon" path="http://ecqi.healthit.gov/ecqms/QICoreCommon" version="2.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="209">
               <a:s>include </a:s>
               <a:s>
                  <a:s>QICoreCommon</a:s>
               </a:s>
               <a:s> version '2.1.000' called QICoreCommon</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="210" locator="8:1-8:85" localIdentifier="AdultOutpatientEncounters" path="http://ecqi.healthit.gov/ecqms/AdultOutpatientEncounters" version="4.11.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="210">
               <a:s>include </a:s>
               <a:s>
                  <a:s>AdultOutpatientEncounters</a:s>
               </a:s>
               <a:s> version '4.11.000' called AdultOutpatientEncounters</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="211" locator="9:1-9:49" localIdentifier="Hospice" path="http://ecqi.healthit.gov/ecqms/Hospice" version="6.12.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="211">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Hospice</a:s>
               </a:s>
               <a:s> version '6.12.000' called Hospice</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="212" locator="10:1-10:46" localIdentifier="Status" path="http://ecqi.healthit.gov/ecqms/Status" version="1.8.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="212">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Status</a:s>
               </a:s>
               <a:s> version '1.8.000' called Status</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="213" locator="11:1-11:63" localIdentifier="PalliativeCare" path="http://ecqi.healthit.gov/ecqms/PalliativeCare" version="1.11.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="213">
               <a:s>include </a:s>
               <a:s>
                  <a:s>PalliativeCare</a:s>
               </a:s>
               <a:s> version '1.11.000' called PalliativeCare</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="214" locator="12:1-12:71" localIdentifier="AIFrailLTCF" path="http://ecqi.healthit.gov/ecqms/AdvancedIllnessandFrailty" version="1.16.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="214">
               <a:s>include </a:s>
               <a:s>
                  <a:s>AdvancedIllnessandFrailty</a:s>
               </a:s>
               <a:s> version '1.16.000' called AIFrailLTCF</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <parameters>
      <def localId="232" locator="31:1-31:49" name="Measurement Period" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="232">
               <a:s>parameter &quot;Measurement Period&quot; </a:s>
               <a:s r="233">
                  <a:s>Interval&lt;</a:s>
                  <a:s r="234">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
            </a:s>
         </annotation>
         <parameterTypeSpecifier localId="233" locator="31:32-31:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="234" locator="31:41-31:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <codeSystems>
      <def localId="215" locator="14:1-14:98" name="AdministrativeGender" id="http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="215">
               <a:s>codesystem &quot;AdministrativeGender&quot;: 'http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="216" locator="15:1-15:47" name="SNOMEDCT" id="http://snomed.info/sct" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="216">
               <a:s>codesystem &quot;SNOMEDCT&quot;: 'http://snomed.info/sct'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="217" locator="16:1-16:38" name="LOINC" id="http://loinc.org" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="217">
               <a:s>codesystem &quot;LOINC&quot;: 'http://loinc.org'</a:s>
            </a:s>
         </annotation>
      </def>
   </codeSystems>
   <valueSets>
      <def localId="218" locator="18:1-18:112" name="Bilateral Mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="218">
               <a:s>valueset &quot;Bilateral Mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="219" locator="19:1-19:123" name="History of bilateral mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="219">
               <a:s>valueset &quot;History of bilateral mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="220" locator="20:1-20:103" name="Mammography" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="220">
               <a:s>valueset &quot;Mammography&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="221" locator="21:1-21:119" name="Status Post Left Mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="221">
               <a:s>valueset &quot;Status Post Left Mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="222" locator="22:1-22:120" name="Status Post Right Mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="222">
               <a:s>valueset &quot;Status Post Right Mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="223" locator="23:1-23:118" name="Unilateral Mastectomy Left" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="223">
               <a:s>valueset &quot;Unilateral Mastectomy Left&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="224" locator="24:1-24:119" name="Unilateral Mastectomy Right" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="224">
               <a:s>valueset &quot;Unilateral Mastectomy Right&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="225" locator="25:1-25:137" name="Unilateral Mastectomy, Unspecified Laterality" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="225">
               <a:s>valueset &quot;Unilateral Mastectomy, Unspecified Laterality&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071'</a:s>
            </a:s>
         </annotation>
      </def>
   </valueSets>
   <codes>
      <def localId="226" locator="27:1-27:63" name="Female" id="F" display="Female" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="226">
               <a:s>code &quot;Female&quot;: 'F' from </a:s>
               <a:s r="227">
                  <a:s>&quot;AdministrativeGender&quot;</a:s>
               </a:s>
               <a:s> display 'Female'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="227" locator="27:25-27:46" name="AdministrativeGender"/>
      </def>
      <def localId="228" locator="28:1-28:89" name="Left (qualifier value)" id="7771000" display="Left (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="228">
               <a:s>code &quot;Left (qualifier value)&quot;: '7771000' from </a:s>
               <a:s r="229">
                  <a:s>&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Left (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="229" locator="28:47-28:56" name="SNOMEDCT"/>
      </def>
      <def localId="230" locator="29:1-29:92" name="Right (qualifier value)" id="24028007" display="Right (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="230">
               <a:s>code &quot;Right (qualifier value)&quot;: '24028007' from </a:s>
               <a:s r="231">
                  <a:s>&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Right (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="231" locator="29:49-29:58" name="SNOMEDCT"/>
      </def>
   </codes>
   <contexts>
      <def localId="238" locator="33:1-33:15" name="Patient"/>
   </contexts>
   <statements>
      <def localId="236" locator="33:1-33:15" name="Patient" context="Patient">
         <expression localId="237" xsi:type="SingletonFrom">
            <operand localId="235" locator="33:1-33:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="240" locator="35:1-40:64" name="Initial Population" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="240">
               <a:s>define &quot;Initial Population&quot;:
  </a:s>
               <a:s r="241">
                  <a:s r="242">
                     <a:s r="255">
                        <a:s r="251">
                           <a:s>AgeInYearsAt(</a:s>
                           <a:s r="243">
                              <a:s>date from 
    </a:s>
                              <a:s r="244">
                                 <a:s>end of </a:s>
                                 <a:s r="245">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
  )</a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="254">
                           <a:s r="252">Interval[52, 74]</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    and </a:s>
                     <a:s r="256">
                        <a:s r="259">
                           <a:s r="257">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="259">
                              <a:s>gender</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="260">
                           <a:s>'female'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    and </a:s>
                  <a:s r="261">
                     <a:s>exists </a:s>
                     <a:s r="263">
                        <a:s r="262">
                           <a:s>AdultOutpatientEncounters</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="263">
                           <a:s>&quot;Qualifying Encounters&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="241" locator="36:3-40:64" xsi:type="And">
            <operand localId="242" locator="36:3-39:33" xsi:type="And">
               <operand localId="255" locator="36:3-38:23" xsi:type="In">
                  <operand localId="251" locator="36:3-38:3" precision="Year" xsi:type="CalculateAgeAt">
                     <operand localId="250" path="value" xsi:type="Property">
                        <source localId="249" path="birthDate" xsi:type="Property">
                           <source localId="248" name="Patient" xsi:type="ExpressionRef"/>
                        </source>
                     </operand>
                     <operand localId="243" locator="36:16-37:31" xsi:type="DateFrom">
                        <operand localId="244" locator="37:5-37:31" xsi:type="End">
                           <operand localId="245" locator="37:12-37:31" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="254" locator="38:8-38:23" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="252" locator="38:17-38:18" valueType="t:Integer" value="52" xsi:type="Literal"/>
                     <high localId="253" locator="38:21-38:22" valueType="t:Integer" value="74" xsi:type="Literal"/>
                  </operand>
               </operand>
               <operand localId="256" locator="39:9-39:33" xsi:type="Equal">
                  <operand localId="259" locator="39:9-39:22" path="value" xsi:type="Property">
                     <source localId="258" path="gender" xsi:type="Property">
                        <source localId="257" locator="39:9-39:15" name="Patient" xsi:type="ExpressionRef"/>
                     </source>
                  </operand>
                  <operand localId="260" locator="39:26-39:33" valueType="t:String" value="female" xsi:type="Literal"/>
               </operand>
            </operand>
            <operand localId="261" locator="40:9-40:64" xsi:type="Exists">
               <operand localId="263" locator="40:16-40:64" name="Qualifying Encounters" libraryName="AdultOutpatientEncounters" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="265" locator="42:1-43:22" name="Denominator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="265">
               <a:s>define &quot;Denominator&quot;:
  </a:s>
               <a:s r="266">
                  <a:s>&quot;Initial Population&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="266" locator="43:3-43:22" name="Initial Population" xsi:type="ExpressionRef"/>
      </def>
      <def localId="281" locator="60:1-67:96" name="Right Mastectomy Diagnosis" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="281">
               <a:s>define &quot;Right Mastectomy Diagnosis&quot;:
  </a:s>
               <a:s r="317">
                  <a:s>
                     <a:s r="282">
                        <a:s r="310">
                           <a:s>( </a:s>
                           <a:s r="310">
                              <a:s r="288">
                                 <a:s>
                                    <a:s r="283">
                                       <a:s r="286">
                                          <a:s r="286">
                                             <a:s>[Condition: </a:s>
                                             <a:s>
                                                <a:s>&quot;Status Post Right Mastectomy&quot;</a:s>
                                             </a:s>
                                             <a:s>]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> RightMastectomyProcedure</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
    union </a:s>
                              <a:s r="309">
                                 <a:s>( </a:s>
                                 <a:s r="309">
                                    <a:s>
                                       <a:s r="289">
                                          <a:s r="292">
                                             <a:s r="292">
                                                <a:s>[Condition: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Unilateral Mastectomy, Unspecified Laterality&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> UnilateralMastectomyDiagnosis</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s r="294">
                                       <a:s>where </a:s>
                                       <a:s r="294">
                                          <a:s>exists </a:s>
                                          <a:s r="308">
                                             <a:s>( </a:s>
                                             <a:s r="308">
                                                <a:s>
                                                   <a:s r="295">
                                                      <a:s r="298">
                                                         <a:s>
                                                            <a:s>UnilateralMastectomyDiagnosis.bodySite</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s> S</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>
            </a:s>
                                                <a:s r="303">
                                                   <a:s>where </a:s>
                                                   <a:s r="303">
                                                      <a:s r="304">
                                                         <a:s>S</a:s>
                                                      </a:s>
                                                      <a:s> ~ </a:s>
                                                      <a:s r="305">
                                                         <a:s>&quot;Right (qualifier value)&quot;</a:s>
                                                      </a:s>
                                                   </a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
        )</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> RightMastectomy</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="316">
                     <a:s>where </a:s>
                     <a:s r="316">
                        <a:s r="312">
                           <a:s r="311">
                              <a:s>RightMastectomy</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="312">
                              <a:s>prevalenceInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="316"> starts on or before </a:s>
                        <a:s r="313">
                           <a:s>end of </a:s>
                           <a:s r="314">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="317" locator="61:3-67:96" xsi:type="Query">
            <source localId="282" locator="61:3-66:23" alias="RightMastectomy">
               <expression localId="310" locator="61:3-66:7" xsi:type="Union">
                  <operand localId="288" locator="61:5-61:72" xsi:type="Query">
                     <source localId="283" locator="61:5-61:72" alias="RightMastectomyProcedure">
                        <expression localId="286" locator="61:5-61:47" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="285" locator="61:17-61:46" name="Status Post Right Mastectomy" preserve="true" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                  </operand>
                  <operand localId="309" locator="62:11-66:5" xsi:type="Query">
                     <source localId="289" locator="62:13-62:102" alias="UnilateralMastectomyDiagnosis">
                        <expression localId="292" locator="62:13-62:72" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="291" locator="62:25-62:71" name="Unilateral Mastectomy, Unspecified Laterality" preserve="true" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="294" locator="63:9-65:9" xsi:type="Exists">
                        <operand localId="308" locator="63:22-65:9" xsi:type="Query">
                           <source localId="295" locator="63:24-63:63" alias="S">
                              <expression localId="298" locator="63:24-63:61" xsi:type="Query">
                                 <source localId="299" alias="$this">
                                    <expression localId="297" path="bodySite" scope="UnilateralMastectomyDiagnosis" xsi:type="Property"/>
                                 </source>
                                 <return localId="302" distinct="false">
                                    <expression localId="300" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="301" name="$this" xsi:type="AliasRef"/>
                                    </expression>
                                 </return>
                              </expression>
                           </source>
                           <where localId="303" locator="64:13-64:47" xsi:type="Equivalent">
                              <operand localId="304" locator="64:19" name="S" xsi:type="AliasRef"/>
                              <operand localId="307" xsi:type="ToConcept">
                                 <operand localId="305" locator="64:23-64:47" name="Right (qualifier value)" xsi:type="CodeRef"/>
                              </operand>
                           </where>
                        </operand>
                     </where>
                  </operand>
               </expression>
            </source>
            <where localId="316" locator="67:5-67:96" xsi:type="SameOrBefore">
               <operand localId="315" locator="67:50-67:55" xsi:type="Start">
                  <operand localId="312" locator="67:11-67:48" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="311" locator="67:11-67:25" name="RightMastectomy" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="313" locator="67:70-67:96" xsi:type="End">
                  <operand localId="314" locator="67:77-67:96" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="321" locator="69:1-71:115" name="Right Mastectomy Procedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="321">
               <a:s>define &quot;Right Mastectomy Procedure&quot;:
  </a:s>
               <a:s r="336">
                  <a:s>
                     <a:s r="322">
                        <a:s r="327">
                           <a:s>( </a:s>
                           <a:s r="327">
                              <a:s r="325">
                                 <a:s>( </a:s>
                                 <a:s r="325">
                                    <a:s>[Procedure: </a:s>
                                    <a:s>
                                       <a:s>&quot;Unilateral Mastectomy Right&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="327">
                                 <a:s>isProcedurePerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> UnilateralMastectomyRightPerformed</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="335">
                     <a:s>where </a:s>
                     <a:s r="335">
                        <a:s r="331">
                           <a:s r="330">
                              <a:s r="328">
                                 <a:s>UnilateralMastectomyRightPerformed</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="330">
                                 <a:s>performed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="331">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="335"> ends on or before </a:s>
                        <a:s r="332">
                           <a:s>end of </a:s>
                           <a:s r="333">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="336" locator="70:3-71:115" xsi:type="Query">
            <source localId="322" locator="70:3-70:112" alias="UnilateralMastectomyRightPerformed">
               <expression localId="327" locator="70:3-70:77" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="325" locator="70:5-70:50" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="324" locator="70:19-70:47" name="Unilateral Mastectomy Right" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="335" locator="71:5-71:115" xsi:type="SameOrBefore">
               <operand localId="334" locator="71:71-71:74" xsi:type="End">
                  <operand localId="331" locator="71:11-71:69" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="330" locator="71:11-71:54" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="329" path="performed" scope="UnilateralMastectomyRightPerformed" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="332" locator="71:89-71:115" xsi:type="End">
                  <operand localId="333" locator="71:96-71:115" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="341" locator="73:1-80:95" name="Left Mastectomy Diagnosis" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="341">
               <a:s>define &quot;Left Mastectomy Diagnosis&quot;:
  </a:s>
               <a:s r="375">
                  <a:s>
                     <a:s r="342">
                        <a:s r="368">
                           <a:s>( </a:s>
                           <a:s r="368">
                              <a:s r="345">
                                 <a:s>[Condition: </a:s>
                                 <a:s>
                                    <a:s>&quot;Status Post Left Mastectomy&quot;</a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                              <a:s>
    union </a:s>
                              <a:s r="367">
                                 <a:s>( </a:s>
                                 <a:s r="367">
                                    <a:s>
                                       <a:s r="347">
                                          <a:s r="350">
                                             <a:s r="350">
                                                <a:s>[Condition: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Unilateral Mastectomy, Unspecified Laterality&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> UnilateralMastectomyDiagnosis</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s r="352">
                                       <a:s>where </a:s>
                                       <a:s r="352">
                                          <a:s>exists </a:s>
                                          <a:s r="366">
                                             <a:s>( </a:s>
                                             <a:s r="366">
                                                <a:s>
                                                   <a:s r="353">
                                                      <a:s r="356">
                                                         <a:s>
                                                            <a:s>UnilateralMastectomyDiagnosis.bodySite</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s> S</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>
            </a:s>
                                                <a:s r="361">
                                                   <a:s>where </a:s>
                                                   <a:s r="361">
                                                      <a:s r="362">
                                                         <a:s>S</a:s>
                                                      </a:s>
                                                      <a:s> ~ </a:s>
                                                      <a:s r="363">
                                                         <a:s>&quot;Left (qualifier value)&quot;</a:s>
                                                      </a:s>
                                                   </a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
        )</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> LeftMastectomy</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="374">
                     <a:s>where </a:s>
                     <a:s r="374">
                        <a:s r="370">
                           <a:s r="369">
                              <a:s>LeftMastectomy</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="370">
                              <a:s>prevalenceInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="374"> starts on or before </a:s>
                        <a:s r="371">
                           <a:s>end of </a:s>
                           <a:s r="372">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="375" locator="74:3-80:95" xsi:type="Query">
            <source localId="342" locator="74:3-79:22" alias="LeftMastectomy">
               <expression localId="368" locator="74:3-79:7" xsi:type="Union">
                  <operand localId="345" locator="74:5-74:46" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="344" locator="74:17-74:45" name="Status Post Left Mastectomy" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
                  <operand localId="367" locator="75:11-79:5" xsi:type="Query">
                     <source localId="347" locator="75:13-75:102" alias="UnilateralMastectomyDiagnosis">
                        <expression localId="350" locator="75:13-75:72" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="349" locator="75:25-75:71" name="Unilateral Mastectomy, Unspecified Laterality" preserve="true" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="352" locator="76:9-78:9" xsi:type="Exists">
                        <operand localId="366" locator="76:22-78:9" xsi:type="Query">
                           <source localId="353" locator="76:24-76:63" alias="S">
                              <expression localId="356" locator="76:24-76:61" xsi:type="Query">
                                 <source localId="357" alias="$this">
                                    <expression localId="355" path="bodySite" scope="UnilateralMastectomyDiagnosis" xsi:type="Property"/>
                                 </source>
                                 <return localId="360" distinct="false">
                                    <expression localId="358" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="359" name="$this" xsi:type="AliasRef"/>
                                    </expression>
                                 </return>
                              </expression>
                           </source>
                           <where localId="361" locator="77:13-77:46" xsi:type="Equivalent">
                              <operand localId="362" locator="77:19" name="S" xsi:type="AliasRef"/>
                              <operand localId="365" xsi:type="ToConcept">
                                 <operand localId="363" locator="77:23-77:46" name="Left (qualifier value)" xsi:type="CodeRef"/>
                              </operand>
                           </where>
                        </operand>
                     </where>
                  </operand>
               </expression>
            </source>
            <where localId="374" locator="80:5-80:95" xsi:type="SameOrBefore">
               <operand localId="373" locator="80:49-80:54" xsi:type="Start">
                  <operand localId="370" locator="80:11-80:47" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="369" locator="80:11-80:24" name="LeftMastectomy" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="371" locator="80:69-80:95" xsi:type="End">
                  <operand localId="372" locator="80:76-80:95" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="379" locator="82:1-84:114" name="Left Mastectomy Procedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="379">
               <a:s>define &quot;Left Mastectomy Procedure&quot;:
  </a:s>
               <a:s r="394">
                  <a:s>
                     <a:s r="380">
                        <a:s r="385">
                           <a:s>( </a:s>
                           <a:s r="385">
                              <a:s r="383">
                                 <a:s>( </a:s>
                                 <a:s r="383">
                                    <a:s>[Procedure: </a:s>
                                    <a:s>
                                       <a:s>&quot;Unilateral Mastectomy Left&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="385">
                                 <a:s>isProcedurePerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> UnilateralMastectomyLeftPerformed</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="393">
                     <a:s>where </a:s>
                     <a:s r="393">
                        <a:s r="389">
                           <a:s r="388">
                              <a:s r="386">
                                 <a:s>UnilateralMastectomyLeftPerformed</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="388">
                                 <a:s>performed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="389">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="393"> ends on or before </a:s>
                        <a:s r="390">
                           <a:s>end of </a:s>
                           <a:s r="391">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="394" locator="83:3-84:114" xsi:type="Query">
            <source localId="380" locator="83:3-83:110" alias="UnilateralMastectomyLeftPerformed">
               <expression localId="385" locator="83:3-83:76" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="383" locator="83:5-83:49" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="382" locator="83:19-83:46" name="Unilateral Mastectomy Left" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="393" locator="84:5-84:114" xsi:type="SameOrBefore">
               <operand localId="392" locator="84:70-84:73" xsi:type="End">
                  <operand localId="389" locator="84:11-84:68" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="388" locator="84:11-84:53" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="387" path="performed" scope="UnilateralMastectomyLeftPerformed" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="390" locator="84:88-84:114" xsi:type="End">
                  <operand localId="391" locator="84:95-84:114" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="398" locator="86:1-88:107" name="Bilateral Mastectomy Diagnosis" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="398">
               <a:s>define &quot;Bilateral Mastectomy Diagnosis&quot;:
  </a:s>
               <a:s r="410">
                  <a:s>
                     <a:s r="399">
                        <a:s r="402">
                           <a:s r="402">
                              <a:s>[Condition: </a:s>
                              <a:s>
                                 <a:s>&quot;History of bilateral mastectomy&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> BilateralMastectomyHistory</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="409">
                     <a:s>where </a:s>
                     <a:s r="409">
                        <a:s r="405">
                           <a:s r="404">
                              <a:s>BilateralMastectomyHistory</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="405">
                              <a:s>prevalenceInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="409"> starts on or before </a:s>
                        <a:s r="406">
                           <a:s>end of </a:s>
                           <a:s r="407">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="410" locator="87:3-88:107" xsi:type="Query">
            <source localId="399" locator="87:3-87:75" alias="BilateralMastectomyHistory">
               <expression localId="402" locator="87:3-87:48" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                  <codes localId="401" locator="87:15-87:47" name="History of bilateral mastectomy" preserve="true" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="409" locator="88:5-88:107" xsi:type="SameOrBefore">
               <operand localId="408" locator="88:61-88:66" xsi:type="Start">
                  <operand localId="405" locator="88:11-88:59" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="404" locator="88:11-88:36" name="BilateralMastectomyHistory" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="406" locator="88:81-88:107" xsi:type="End">
                  <operand localId="407" locator="88:88-88:107" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="414" locator="90:1-92:109" name="Bilateral Mastectomy Procedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="414">
               <a:s>define &quot;Bilateral Mastectomy Procedure&quot;:
  </a:s>
               <a:s r="429">
                  <a:s>
                     <a:s r="415">
                        <a:s r="420">
                           <a:s>( </a:s>
                           <a:s r="420">
                              <a:s r="418">
                                 <a:s>( </a:s>
                                 <a:s r="418">
                                    <a:s>[Procedure: </a:s>
                                    <a:s>
                                       <a:s>&quot;Bilateral Mastectomy&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="420">
                                 <a:s>isProcedurePerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> BilateralMastectomyPerformed</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="428">
                     <a:s>where </a:s>
                     <a:s r="428">
                        <a:s r="424">
                           <a:s r="423">
                              <a:s r="421">
                                 <a:s>BilateralMastectomyPerformed</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="423">
                                 <a:s>performed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="424">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="428"> ends on or before </a:s>
                        <a:s r="425">
                           <a:s>end of </a:s>
                           <a:s r="426">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="429" locator="91:3-92:109" xsi:type="Query">
            <source localId="415" locator="91:3-91:99" alias="BilateralMastectomyPerformed">
               <expression localId="420" locator="91:3-91:70" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="418" locator="91:5-91:43" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="417" locator="91:19-91:40" name="Bilateral Mastectomy" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="428" locator="92:5-92:109" xsi:type="SameOrBefore">
               <operand localId="427" locator="92:65-92:68" xsi:type="End">
                  <operand localId="424" locator="92:11-92:63" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="423" locator="92:11-92:48" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="422" path="performed" scope="BilateralMastectomyPerformed" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="425" locator="92:83-92:109" xsi:type="End">
                  <operand localId="426" locator="92:90-92:109" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="268" locator="45:1-58:69" name="Denominator Exclusions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="268">
               <a:s>define &quot;Denominator Exclusions&quot;:
  </a:s>
               <a:s r="269">
                  <a:s r="270">
                     <a:s r="271">
                        <a:s r="272">
                           <a:s r="273">
                              <a:s r="274">
                                 <a:s r="276">
                                    <a:s r="275">
                                       <a:s>Hospice</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="276">
                                       <a:s>&quot;Has Hospice Services&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    or </a:s>
                                 <a:s r="277">
                                    <a:s>( </a:s>
                                    <a:s r="277">
                                       <a:s r="278">
                                          <a:s>( </a:s>
                                          <a:s r="278">
                                             <a:s r="279">
                                                <a:s>exists </a:s>
                                                <a:s r="318">
                                                   <a:s>( </a:s>
                                                   <a:s r="318">
                                                      <a:s>&quot;Right Mastectomy Diagnosis&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
          or </a:s>
                                             <a:s r="319">
                                                <a:s>exists </a:s>
                                                <a:s r="337">
                                                   <a:s>( </a:s>
                                                   <a:s r="337">
                                                      <a:s>&quot;Right Mastectomy Procedure&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
      )</a:s>
                                       </a:s>
                                       <a:s>
        and </a:s>
                                       <a:s r="338">
                                          <a:s>( </a:s>
                                          <a:s r="338">
                                             <a:s r="339">
                                                <a:s>exists </a:s>
                                                <a:s r="376">
                                                   <a:s>( </a:s>
                                                   <a:s r="376">
                                                      <a:s>&quot;Left Mastectomy Diagnosis&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
            or </a:s>
                                             <a:s r="377">
                                                <a:s>exists </a:s>
                                                <a:s r="395">
                                                   <a:s>( </a:s>
                                                   <a:s r="395">
                                                      <a:s>&quot;Left Mastectomy Procedure&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
        )</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
    )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
    or </a:s>
                              <a:s r="396">
                                 <a:s>exists </a:s>
                                 <a:s r="411">
                                    <a:s>&quot;Bilateral Mastectomy Diagnosis&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    or </a:s>
                           <a:s r="412">
                              <a:s>exists </a:s>
                              <a:s r="430">
                                 <a:s>&quot;Bilateral Mastectomy Procedure&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    or </a:s>
                        <a:s r="432">
                           <a:s r="431">
                              <a:s>AIFrailLTCF</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="432">
                              <a:s>&quot;Is Age 66 or Older with Advanced Illness and Frailty&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="434">
                        <a:s r="433">
                           <a:s>AIFrailLTCF</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="434">
                           <a:s>&quot;Is Age 66 or Older Living Long Term in a Nursing Home&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    or </a:s>
                  <a:s r="436">
                     <a:s r="435">
                        <a:s>PalliativeCare</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="436">
                        <a:s>&quot;Has Palliative Care in the Measurement Period&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="269" locator="46:3-58:69" xsi:type="Or">
            <operand localId="270" locator="46:3-57:74" xsi:type="Or">
               <operand localId="271" locator="46:3-56:73" xsi:type="Or">
                  <operand localId="272" locator="46:3-55:46" xsi:type="Or">
                     <operand localId="273" locator="46:3-54:46" xsi:type="Or">
                        <operand localId="274" locator="46:3-53:5" xsi:type="Or">
                           <operand localId="276" locator="46:3-46:32" name="Has Hospice Services" libraryName="Hospice" xsi:type="ExpressionRef"/>
                           <operand localId="277" locator="47:8-53:5" xsi:type="And">
                              <operand localId="278" locator="47:10-49:7" xsi:type="Or">
                                 <operand localId="279" locator="47:12-47:50" xsi:type="Exists">
                                    <operand localId="318" locator="47:19-47:50" name="Right Mastectomy Diagnosis" xsi:type="ExpressionRef"/>
                                 </operand>
                                 <operand localId="319" locator="48:14-48:52" xsi:type="Exists">
                                    <operand localId="337" locator="48:21-48:52" name="Right Mastectomy Procedure" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="338" locator="50:13-52:9" xsi:type="Or">
                                 <operand localId="339" locator="50:15-50:52" xsi:type="Exists">
                                    <operand localId="376" locator="50:22-50:52" name="Left Mastectomy Diagnosis" xsi:type="ExpressionRef"/>
                                 </operand>
                                 <operand localId="377" locator="51:16-51:53" xsi:type="Exists">
                                    <operand localId="395" locator="51:23-51:53" name="Left Mastectomy Procedure" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                           </operand>
                        </operand>
                        <operand localId="396" locator="54:8-54:46" xsi:type="Exists">
                           <operand localId="411" locator="54:15-54:46" name="Bilateral Mastectomy Diagnosis" xsi:type="ExpressionRef"/>
                        </operand>
                     </operand>
                     <operand localId="412" locator="55:8-55:46" xsi:type="Exists">
                        <operand localId="430" locator="55:15-55:46" name="Bilateral Mastectomy Procedure" xsi:type="ExpressionRef"/>
                     </operand>
                  </operand>
                  <operand localId="432" locator="56:8-56:73" name="Is Age 66 or Older with Advanced Illness and Frailty" libraryName="AIFrailLTCF" xsi:type="ExpressionRef"/>
               </operand>
               <operand localId="434" locator="57:8-57:74" name="Is Age 66 or Older Living Long Term in a Nursing Home" libraryName="AIFrailLTCF" xsi:type="ExpressionRef"/>
            </operand>
            <operand localId="436" locator="58:8-58:69" name="Has Palliative Care in the Measurement Period" libraryName="PalliativeCare" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="451" locator="99:1-100:79" name="October 1 Two Years Prior to the Measurement Period" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="451">
               <a:s>define &quot;October 1 Two Years Prior to the Measurement Period&quot;:
  </a:s>
               <a:s r="468">
                  <a:s>DateTime(</a:s>
                  <a:s r="452">
                     <a:s>(</a:s>
                     <a:s r="452">
                        <a:s r="453">
                           <a:s>year from </a:s>
                           <a:s r="454">
                              <a:s>start of </a:s>
                              <a:s r="455">
                                 <a:s>&quot;Measurement Period&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s r="456"> - 2</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
                  <a:s r="457">, 10, 1, 0, 0, 0, 0, 0)</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="468" locator="100:3-100:79" xsi:type="DateTime">
            <year localId="452" locator="100:12-100:56" xsi:type="Subtract">
               <operand localId="453" locator="100:13-100:51" precision="Year" xsi:type="DateTimeComponentFrom">
                  <operand localId="454" locator="100:23-100:51" xsi:type="Start">
                     <operand localId="455" locator="100:32-100:51" name="Measurement Period" xsi:type="ParameterRef"/>
                  </operand>
               </operand>
               <operand localId="456" locator="100:55" valueType="t:Integer" value="2" xsi:type="Literal"/>
            </year>
            <month localId="457" locator="100:59-100:60" valueType="t:Integer" value="10" xsi:type="Literal"/>
            <day localId="458" locator="100:63" valueType="t:Integer" value="1" xsi:type="Literal"/>
            <hour localId="459" locator="100:66" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <minute localId="460" locator="100:69" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <second localId="461" locator="100:72" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <millisecond localId="462" locator="100:75" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <timezoneOffset localId="470" xsi:type="ToDecimal">
               <operand localId="463" locator="100:78" valueType="t:Integer" value="0" xsi:type="Literal"/>
            </timezoneOffset>
         </expression>
      </def>
      <def localId="438" locator="94:1-97:3" name="Numerator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="438">
               <a:s>define &quot;Numerator&quot;:
  </a:s>
               <a:s r="439">
                  <a:s>exists </a:s>
                  <a:s r="477">
                     <a:s>( </a:s>
                     <a:s r="477">
                        <a:s>
                           <a:s r="440">
                              <a:s r="445">
                                 <a:s>( </a:s>
                                 <a:s r="445">
                                    <a:s r="443">
                                       <a:s>( </a:s>
                                       <a:s r="443">
                                          <a:s>[Observation: </a:s>
                                          <a:s>
                                             <a:s>&quot;Mammography&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                       <a:s> )</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="445">
                                       <a:s>isDiagnosticStudyPerformed ( )</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s> Mammogram</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="476">
                           <a:s>where </a:s>
                           <a:s r="476">
                              <a:s r="449">
                                 <a:s r="448">
                                    <a:s r="446">
                                       <a:s>Mammogram</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="448">
                                       <a:s>effective</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="449">
                                    <a:s>toInterval ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="476"> ends during day of </a:s>
                              <a:s r="474">
                                 <a:s>Interval[</a:s>
                                 <a:s r="471">
                                    <a:s>&quot;October 1 Two Years Prior to the Measurement Period&quot;</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="472">
                                    <a:s>end of </a:s>
                                    <a:s r="473">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="439" locator="95:3-97:3" xsi:type="Exists">
            <operand localId="477" locator="95:10-97:3" xsi:type="Query">
               <source localId="440" locator="95:12-95:88" alias="Mammogram">
                  <expression localId="445" locator="95:12-95:78" name="isDiagnosticStudyPerformed" libraryName="Status" xsi:type="FunctionRef">
                     <operand localId="443" locator="95:14-95:45" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                        <codes localId="442" locator="95:30-95:42" name="Mammography" preserve="true" xsi:type="ValueSetRef"/>
                     </operand>
                  </expression>
               </source>
               <where localId="476" locator="96:7-96:158" precision="Day" xsi:type="In">
                  <operand localId="475" locator="96:48-96:51" xsi:type="End">
                     <operand localId="449" locator="96:13-96:46" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                        <operand localId="448" locator="96:13-96:31" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="447" path="effective" scope="Mammogram" xsi:type="Property"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="474" locator="96:67-96:158" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="471" locator="96:76-96:128" name="October 1 Two Years Prior to the Measurement Period" xsi:type="ExpressionRef"/>
                     <high localId="472" locator="96:131-96:157" xsi:type="End">
                        <operand localId="473" locator="96:138-96:157" name="Measurement Period" xsi:type="ParameterRef"/>
                     </high>
                  </operand>
               </where>
            </operand>
         </expression>
      </def>
      <def localId="479" locator="102:1-103:21" name="SDE Ethnicity" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="479">
               <a:s>define &quot;SDE Ethnicity&quot;:
  </a:s>
               <a:s r="481">
                  <a:s r="480">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="481">
                     <a:s>&quot;SDE Ethnicity&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="481" locator="103:3-103:21" name="SDE Ethnicity" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="483" locator="105:1-106:17" name="SDE Payer" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="483">
               <a:s>define &quot;SDE Payer&quot;:
  </a:s>
               <a:s r="485">
                  <a:s r="484">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="485">
                     <a:s>&quot;SDE Payer&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="485" locator="106:3-106:17" name="SDE Payer" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="487" locator="108:1-109:16" name="SDE Race" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="487">
               <a:s>define &quot;SDE Race&quot;:
  </a:s>
               <a:s r="489">
                  <a:s r="488">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="489">
                     <a:s>&quot;SDE Race&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="489" locator="109:3-109:16" name="SDE Race" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="491" locator="111:1-112:15" name="SDE Sex" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="491">
               <a:s>define &quot;SDE Sex&quot;:
  </a:s>
               <a:s r="493">
                  <a:s r="492">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="493">
                     <a:s>&quot;SDE Sex&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="493" locator="112:3-112:15" name="SDE Sex" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
   </statements>
</library>
" + }, + { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "localId" : "0",
      "annotation" : [ {
         "translatorVersion" : "3.10.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "signatureLevel" : "None",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "s" : {
            "r" : "491",
            "s" : [ {
               "value" : [ "","library BreastCancerScreeningFHIR version '0.0.001'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "BreastCancerScreeningFHIR",
         "system" : "http://ecqi.healthit.gov/ecqms",
         "version" : "0.0.001"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localId" : "1",
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "206",
            "locator" : "3:1-3:28",
            "localIdentifier" : "QICore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "206",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICore" ]
                     } ]
                  }, {
                     "value" : [ " version '4.1.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "207",
            "locator" : "5:1-5:56",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://ecqi.healthit.gov/ecqms/FHIRHelpers",
            "version" : "4.4.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "207",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.4.000'"," called ","FHIRHelpers" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "208",
            "locator" : "6:1-6:61",
            "localIdentifier" : "SDE",
            "path" : "http://ecqi.healthit.gov/ecqms/SupplementalDataElements",
            "version" : "3.5.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "208",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "SupplementalDataElements" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.5.000'"," called ","SDE" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "209",
            "locator" : "7:1-7:58",
            "localIdentifier" : "QICoreCommon",
            "path" : "http://ecqi.healthit.gov/ecqms/QICoreCommon",
            "version" : "2.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "209",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'2.1.000'"," called ","QICoreCommon" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "210",
            "locator" : "8:1-8:85",
            "localIdentifier" : "AdultOutpatientEncounters",
            "path" : "http://ecqi.healthit.gov/ecqms/AdultOutpatientEncounters",
            "version" : "4.11.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "210",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "AdultOutpatientEncounters" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.11.000'"," called ","AdultOutpatientEncounters" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "211",
            "locator" : "9:1-9:49",
            "localIdentifier" : "Hospice",
            "path" : "http://ecqi.healthit.gov/ecqms/Hospice",
            "version" : "6.12.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "211",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Hospice" ]
                     } ]
                  }, {
                     "value" : [ " version ","'6.12.000'"," called ","Hospice" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "212",
            "locator" : "10:1-10:46",
            "localIdentifier" : "Status",
            "path" : "http://ecqi.healthit.gov/ecqms/Status",
            "version" : "1.8.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "212",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Status" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.8.000'"," called ","Status" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "213",
            "locator" : "11:1-11:63",
            "localIdentifier" : "PalliativeCare",
            "path" : "http://ecqi.healthit.gov/ecqms/PalliativeCare",
            "version" : "1.11.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "213",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "PalliativeCare" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.11.000'"," called ","PalliativeCare" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "214",
            "locator" : "12:1-12:71",
            "localIdentifier" : "AIFrailLTCF",
            "path" : "http://ecqi.healthit.gov/ecqms/AdvancedIllnessandFrailty",
            "version" : "1.16.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "214",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "AdvancedIllnessandFrailty" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.16.000'"," called ","AIFrailLTCF" ]
                  } ]
               }
            } ]
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "232",
            "locator" : "31:1-31:49",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "232",
                  "s" : [ {
                     "value" : [ "","parameter ","\"Measurement Period\""," " ]
                  }, {
                     "r" : "233",
                     "s" : [ {
                        "value" : [ "Interval<" ]
                     }, {
                        "r" : "234",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  } ]
               }
            } ],
            "parameterTypeSpecifier" : {
               "localId" : "233",
               "locator" : "31:32-31:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "234",
                  "locator" : "31:41-31:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "215",
            "locator" : "14:1-14:98",
            "name" : "AdministrativeGender",
            "id" : "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "215",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"AdministrativeGender\"",": ","'http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "216",
            "locator" : "15:1-15:47",
            "name" : "SNOMEDCT",
            "id" : "http://snomed.info/sct",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "216",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"SNOMEDCT\"",": ","'http://snomed.info/sct'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "217",
            "locator" : "16:1-16:38",
            "name" : "LOINC",
            "id" : "http://loinc.org",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "217",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"LOINC\"",": ","'http://loinc.org'" ]
                  } ]
               }
            } ]
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "218",
            "locator" : "18:1-18:112",
            "name" : "Bilateral Mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "218",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Bilateral Mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "219",
            "locator" : "19:1-19:123",
            "name" : "History of bilateral mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "219",
                  "s" : [ {
                     "value" : [ "","valueset ","\"History of bilateral mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "220",
            "locator" : "20:1-20:103",
            "name" : "Mammography",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "220",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Mammography\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "221",
            "locator" : "21:1-21:119",
            "name" : "Status Post Left Mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "221",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Status Post Left Mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "222",
            "locator" : "22:1-22:120",
            "name" : "Status Post Right Mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "222",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Status Post Right Mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "223",
            "locator" : "23:1-23:118",
            "name" : "Unilateral Mastectomy Left",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "223",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Unilateral Mastectomy Left\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "224",
            "locator" : "24:1-24:119",
            "name" : "Unilateral Mastectomy Right",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "224",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Unilateral Mastectomy Right\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "225",
            "locator" : "25:1-25:137",
            "name" : "Unilateral Mastectomy, Unspecified Laterality",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "225",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Unilateral Mastectomy, Unspecified Laterality\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "226",
            "locator" : "27:1-27:63",
            "name" : "Female",
            "id" : "F",
            "display" : "Female",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "226",
                  "s" : [ {
                     "value" : [ "","code ","\"Female\"",": ","'F'"," from " ]
                  }, {
                     "r" : "227",
                     "s" : [ {
                        "value" : [ "\"AdministrativeGender\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Female'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "227",
               "locator" : "27:25-27:46",
               "name" : "AdministrativeGender"
            }
         }, {
            "localId" : "228",
            "locator" : "28:1-28:89",
            "name" : "Left (qualifier value)",
            "id" : "7771000",
            "display" : "Left (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "228",
                  "s" : [ {
                     "value" : [ "","code ","\"Left (qualifier value)\"",": ","'7771000'"," from " ]
                  }, {
                     "r" : "229",
                     "s" : [ {
                        "value" : [ "\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Left (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "229",
               "locator" : "28:47-28:56",
               "name" : "SNOMEDCT"
            }
         }, {
            "localId" : "230",
            "locator" : "29:1-29:92",
            "name" : "Right (qualifier value)",
            "id" : "24028007",
            "display" : "Right (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "230",
                  "s" : [ {
                     "value" : [ "","code ","\"Right (qualifier value)\"",": ","'24028007'"," from " ]
                  }, {
                     "r" : "231",
                     "s" : [ {
                        "value" : [ "\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Right (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "231",
               "locator" : "29:49-29:58",
               "name" : "SNOMEDCT"
            }
         } ]
      },
      "contexts" : {
         "def" : [ {
            "localId" : "238",
            "locator" : "33:1-33:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "localId" : "236",
            "locator" : "33:1-33:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "localId" : "237",
               "type" : "SingletonFrom",
               "signature" : [ ],
               "operand" : {
                  "localId" : "235",
                  "locator" : "33:1-33:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient",
                  "type" : "Retrieve",
                  "include" : [ ],
                  "codeFilter" : [ ],
                  "dateFilter" : [ ],
                  "otherFilter" : [ ]
               }
            }
         }, {
            "localId" : "240",
            "locator" : "35:1-40:64",
            "name" : "Initial Population",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "240",
                  "s" : [ {
                     "value" : [ "","define ","\"Initial Population\"",":\n  " ]
                  }, {
                     "r" : "241",
                     "s" : [ {
                        "r" : "242",
                        "s" : [ {
                           "r" : "255",
                           "s" : [ {
                              "r" : "251",
                              "s" : [ {
                                 "value" : [ "AgeInYearsAt","(" ]
                              }, {
                                 "r" : "243",
                                 "s" : [ {
                                    "value" : [ "date from \n    " ]
                                 }, {
                                    "r" : "244",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "245",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n  )" ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "254",
                              "s" : [ {
                                 "r" : "252",
                                 "value" : [ "Interval[","52",", ","74","]" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    and " ]
                        }, {
                           "r" : "256",
                           "s" : [ {
                              "r" : "259",
                              "s" : [ {
                                 "r" : "257",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "259",
                                 "s" : [ {
                                    "value" : [ "gender" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "260",
                              "s" : [ {
                                 "value" : [ "'female'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    and " ]
                     }, {
                        "r" : "261",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "263",
                           "s" : [ {
                              "r" : "262",
                              "s" : [ {
                                 "value" : [ "AdultOutpatientEncounters" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "263",
                              "s" : [ {
                                 "value" : [ "\"Qualifying Encounters\"" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "241",
               "locator" : "36:3-40:64",
               "type" : "And",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "242",
                  "locator" : "36:3-39:33",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "255",
                     "locator" : "36:3-38:23",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "251",
                        "locator" : "36:3-38:3",
                        "precision" : "Year",
                        "type" : "CalculateAgeAt",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "250",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "249",
                              "path" : "birthDate",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "248",
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           }
                        }, {
                           "localId" : "243",
                           "locator" : "36:16-37:31",
                           "type" : "DateFrom",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "244",
                              "locator" : "37:5-37:31",
                              "type" : "End",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "245",
                                 "locator" : "37:12-37:31",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "localId" : "254",
                        "locator" : "38:8-38:23",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "252",
                           "locator" : "38:17-38:18",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "52",
                           "type" : "Literal"
                        },
                        "high" : {
                           "localId" : "253",
                           "locator" : "38:21-38:22",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "74",
                           "type" : "Literal"
                        }
                     } ]
                  }, {
                     "localId" : "256",
                     "locator" : "39:9-39:33",
                     "type" : "Equal",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "259",
                        "locator" : "39:9-39:22",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "258",
                           "path" : "gender",
                           "type" : "Property",
                           "source" : {
                              "localId" : "257",
                              "locator" : "39:9-39:15",
                              "name" : "Patient",
                              "type" : "ExpressionRef"
                           }
                        }
                     }, {
                        "localId" : "260",
                        "locator" : "39:26-39:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "female",
                        "type" : "Literal"
                     } ]
                  } ]
               }, {
                  "localId" : "261",
                  "locator" : "40:9-40:64",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "263",
                     "locator" : "40:16-40:64",
                     "name" : "Qualifying Encounters",
                     "libraryName" : "AdultOutpatientEncounters",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "265",
            "locator" : "42:1-43:22",
            "name" : "Denominator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "265",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator\"",":\n  " ]
                  }, {
                     "r" : "266",
                     "s" : [ {
                        "value" : [ "\"Initial Population\"" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "266",
               "locator" : "43:3-43:22",
               "name" : "Initial Population",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "281",
            "locator" : "60:1-67:96",
            "name" : "Right Mastectomy Diagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "281",
                  "s" : [ {
                     "value" : [ "","define ","\"Right Mastectomy Diagnosis\"",":\n  " ]
                  }, {
                     "r" : "317",
                     "s" : [ {
                        "s" : [ {
                           "r" : "282",
                           "s" : [ {
                              "r" : "310",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "310",
                                 "s" : [ {
                                    "r" : "288",
                                    "s" : [ {
                                       "s" : [ {
                                          "r" : "283",
                                          "s" : [ {
                                             "r" : "286",
                                             "s" : [ {
                                                "r" : "286",
                                                "s" : [ {
                                                   "value" : [ "[","Condition",": " ]
                                                }, {
                                                   "s" : [ {
                                                      "value" : [ "\"Status Post Right Mastectomy\"" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","RightMastectomyProcedure" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    union " ]
                                 }, {
                                    "r" : "309",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "309",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "289",
                                             "s" : [ {
                                                "r" : "292",
                                                "s" : [ {
                                                   "r" : "292",
                                                   "s" : [ {
                                                      "value" : [ "[","Condition",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Unilateral Mastectomy, Unspecified Laterality\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","UnilateralMastectomyDiagnosis" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "r" : "294",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "294",
                                             "s" : [ {
                                                "value" : [ "exists " ]
                                             }, {
                                                "r" : "308",
                                                "s" : [ {
                                                   "value" : [ "( " ]
                                                }, {
                                                   "r" : "308",
                                                   "s" : [ {
                                                      "s" : [ {
                                                         "r" : "295",
                                                         "s" : [ {
                                                            "r" : "298",
                                                            "s" : [ {
                                                               "s" : [ {
                                                                  "value" : [ "UnilateralMastectomyDiagnosis",".","bodySite" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","S" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n            " ]
                                                   }, {
                                                      "r" : "303",
                                                      "s" : [ {
                                                         "value" : [ "where " ]
                                                      }, {
                                                         "r" : "303",
                                                         "s" : [ {
                                                            "r" : "304",
                                                            "s" : [ {
                                                               "value" : [ "S" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","~"," " ]
                                                         }, {
                                                            "r" : "305",
                                                            "s" : [ {
                                                               "value" : [ "\"Right (qualifier value)\"" ]
                                                            } ]
                                                         } ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n        )" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","RightMastectomy" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "316",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "316",
                           "s" : [ {
                              "r" : "312",
                              "s" : [ {
                                 "r" : "311",
                                 "s" : [ {
                                    "value" : [ "RightMastectomy" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "312",
                                 "s" : [ {
                                    "value" : [ "prevalenceInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "316",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "313",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "314",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "317",
               "locator" : "61:3-67:96",
               "type" : "Query",
               "source" : [ {
                  "localId" : "282",
                  "locator" : "61:3-66:23",
                  "alias" : "RightMastectomy",
                  "expression" : {
                     "localId" : "310",
                     "locator" : "61:3-66:7",
                     "type" : "Union",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "288",
                        "locator" : "61:5-61:72",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "283",
                           "locator" : "61:5-61:72",
                           "alias" : "RightMastectomyProcedure",
                           "expression" : {
                              "localId" : "286",
                              "locator" : "61:5-61:47",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "285",
                                 "locator" : "61:17-61:46",
                                 "name" : "Status Post Right Mastectomy",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }
                        } ],
                        "let" : [ ],
                        "relationship" : [ ]
                     }, {
                        "localId" : "309",
                        "locator" : "62:11-66:5",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "289",
                           "locator" : "62:13-62:102",
                           "alias" : "UnilateralMastectomyDiagnosis",
                           "expression" : {
                              "localId" : "292",
                              "locator" : "62:13-62:72",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "291",
                                 "locator" : "62:25-62:71",
                                 "name" : "Unilateral Mastectomy, Unspecified Laterality",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }
                        } ],
                        "let" : [ ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "294",
                           "locator" : "63:9-65:9",
                           "type" : "Exists",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "308",
                              "locator" : "63:22-65:9",
                              "type" : "Query",
                              "source" : [ {
                                 "localId" : "295",
                                 "locator" : "63:24-63:63",
                                 "alias" : "S",
                                 "expression" : {
                                    "localId" : "298",
                                    "locator" : "63:24-63:61",
                                    "type" : "Query",
                                    "source" : [ {
                                       "localId" : "299",
                                       "alias" : "$this",
                                       "expression" : {
                                          "localId" : "297",
                                          "path" : "bodySite",
                                          "scope" : "UnilateralMastectomyDiagnosis",
                                          "type" : "Property"
                                       }
                                    } ],
                                    "let" : [ ],
                                    "relationship" : [ ],
                                    "return" : {
                                       "localId" : "302",
                                       "distinct" : false,
                                       "expression" : {
                                          "localId" : "300",
                                          "name" : "ToConcept",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "301",
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          } ]
                                       }
                                    }
                                 }
                              } ],
                              "let" : [ ],
                              "relationship" : [ ],
                              "where" : {
                                 "localId" : "303",
                                 "locator" : "64:13-64:47",
                                 "type" : "Equivalent",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "304",
                                    "locator" : "64:19",
                                    "name" : "S",
                                    "type" : "AliasRef"
                                 }, {
                                    "localId" : "307",
                                    "type" : "ToConcept",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "305",
                                       "locator" : "64:23-64:47",
                                       "name" : "Right (qualifier value)",
                                       "type" : "CodeRef"
                                    }
                                 } ]
                              }
                           }
                        }
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "316",
                  "locator" : "67:5-67:96",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "315",
                     "locator" : "67:50-67:55",
                     "type" : "Start",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "312",
                        "locator" : "67:11-67:48",
                        "name" : "prevalenceInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "311",
                           "locator" : "67:11-67:25",
                           "name" : "RightMastectomy",
                           "type" : "AliasRef"
                        } ]
                     }
                  }, {
                     "localId" : "313",
                     "locator" : "67:70-67:96",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "314",
                        "locator" : "67:77-67:96",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "321",
            "locator" : "69:1-71:115",
            "name" : "Right Mastectomy Procedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "321",
                  "s" : [ {
                     "value" : [ "","define ","\"Right Mastectomy Procedure\"",":\n  " ]
                  }, {
                     "r" : "336",
                     "s" : [ {
                        "s" : [ {
                           "r" : "322",
                           "s" : [ {
                              "r" : "327",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "327",
                                 "s" : [ {
                                    "r" : "325",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "325",
                                       "s" : [ {
                                          "value" : [ "[","Procedure",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Unilateral Mastectomy Right\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "327",
                                    "s" : [ {
                                       "value" : [ "isProcedurePerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","UnilateralMastectomyRightPerformed" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "335",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "335",
                           "s" : [ {
                              "r" : "331",
                              "s" : [ {
                                 "r" : "330",
                                 "s" : [ {
                                    "r" : "328",
                                    "s" : [ {
                                       "value" : [ "UnilateralMastectomyRightPerformed" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "330",
                                    "s" : [ {
                                       "value" : [ "performed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "331",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "335",
                              "value" : [ " ","ends on or before"," " ]
                           }, {
                              "r" : "332",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "333",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "336",
               "locator" : "70:3-71:115",
               "type" : "Query",
               "source" : [ {
                  "localId" : "322",
                  "locator" : "70:3-70:112",
                  "alias" : "UnilateralMastectomyRightPerformed",
                  "expression" : {
                     "localId" : "327",
                     "locator" : "70:3-70:77",
                     "name" : "isProcedurePerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "325",
                        "locator" : "70:5-70:50",
                        "dataType" : "{http://hl7.org/fhir}Procedure",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "324",
                           "locator" : "70:19-70:47",
                           "name" : "Unilateral Mastectomy Right",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "335",
                  "locator" : "71:5-71:115",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "334",
                     "locator" : "71:71-71:74",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "331",
                        "locator" : "71:11-71:69",
                        "name" : "toInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "330",
                           "locator" : "71:11-71:54",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "329",
                              "path" : "performed",
                              "scope" : "UnilateralMastectomyRightPerformed",
                              "type" : "Property"
                           } ]
                        } ]
                     }
                  }, {
                     "localId" : "332",
                     "locator" : "71:89-71:115",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "333",
                        "locator" : "71:96-71:115",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "341",
            "locator" : "73:1-80:95",
            "name" : "Left Mastectomy Diagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "341",
                  "s" : [ {
                     "value" : [ "","define ","\"Left Mastectomy Diagnosis\"",":\n  " ]
                  }, {
                     "r" : "375",
                     "s" : [ {
                        "s" : [ {
                           "r" : "342",
                           "s" : [ {
                              "r" : "368",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "368",
                                 "s" : [ {
                                    "r" : "345",
                                    "s" : [ {
                                       "value" : [ "[","Condition",": " ]
                                    }, {
                                       "s" : [ {
                                          "value" : [ "\"Status Post Left Mastectomy\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    union " ]
                                 }, {
                                    "r" : "367",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "367",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "347",
                                             "s" : [ {
                                                "r" : "350",
                                                "s" : [ {
                                                   "r" : "350",
                                                   "s" : [ {
                                                      "value" : [ "[","Condition",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Unilateral Mastectomy, Unspecified Laterality\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","UnilateralMastectomyDiagnosis" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "r" : "352",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "352",
                                             "s" : [ {
                                                "value" : [ "exists " ]
                                             }, {
                                                "r" : "366",
                                                "s" : [ {
                                                   "value" : [ "( " ]
                                                }, {
                                                   "r" : "366",
                                                   "s" : [ {
                                                      "s" : [ {
                                                         "r" : "353",
                                                         "s" : [ {
                                                            "r" : "356",
                                                            "s" : [ {
                                                               "s" : [ {
                                                                  "value" : [ "UnilateralMastectomyDiagnosis",".","bodySite" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","S" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n            " ]
                                                   }, {
                                                      "r" : "361",
                                                      "s" : [ {
                                                         "value" : [ "where " ]
                                                      }, {
                                                         "r" : "361",
                                                         "s" : [ {
                                                            "r" : "362",
                                                            "s" : [ {
                                                               "value" : [ "S" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","~"," " ]
                                                         }, {
                                                            "r" : "363",
                                                            "s" : [ {
                                                               "value" : [ "\"Left (qualifier value)\"" ]
                                                            } ]
                                                         } ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n        )" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","LeftMastectomy" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "374",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "374",
                           "s" : [ {
                              "r" : "370",
                              "s" : [ {
                                 "r" : "369",
                                 "s" : [ {
                                    "value" : [ "LeftMastectomy" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "370",
                                 "s" : [ {
                                    "value" : [ "prevalenceInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "374",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "371",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "372",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "375",
               "locator" : "74:3-80:95",
               "type" : "Query",
               "source" : [ {
                  "localId" : "342",
                  "locator" : "74:3-79:22",
                  "alias" : "LeftMastectomy",
                  "expression" : {
                     "localId" : "368",
                     "locator" : "74:3-79:7",
                     "type" : "Union",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "345",
                        "locator" : "74:5-74:46",
                        "dataType" : "{http://hl7.org/fhir}Condition",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "344",
                           "locator" : "74:17-74:45",
                           "name" : "Status Post Left Mastectomy",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     }, {
                        "localId" : "367",
                        "locator" : "75:11-79:5",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "347",
                           "locator" : "75:13-75:102",
                           "alias" : "UnilateralMastectomyDiagnosis",
                           "expression" : {
                              "localId" : "350",
                              "locator" : "75:13-75:72",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "349",
                                 "locator" : "75:25-75:71",
                                 "name" : "Unilateral Mastectomy, Unspecified Laterality",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }
                        } ],
                        "let" : [ ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "352",
                           "locator" : "76:9-78:9",
                           "type" : "Exists",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "366",
                              "locator" : "76:22-78:9",
                              "type" : "Query",
                              "source" : [ {
                                 "localId" : "353",
                                 "locator" : "76:24-76:63",
                                 "alias" : "S",
                                 "expression" : {
                                    "localId" : "356",
                                    "locator" : "76:24-76:61",
                                    "type" : "Query",
                                    "source" : [ {
                                       "localId" : "357",
                                       "alias" : "$this",
                                       "expression" : {
                                          "localId" : "355",
                                          "path" : "bodySite",
                                          "scope" : "UnilateralMastectomyDiagnosis",
                                          "type" : "Property"
                                       }
                                    } ],
                                    "let" : [ ],
                                    "relationship" : [ ],
                                    "return" : {
                                       "localId" : "360",
                                       "distinct" : false,
                                       "expression" : {
                                          "localId" : "358",
                                          "name" : "ToConcept",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "359",
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          } ]
                                       }
                                    }
                                 }
                              } ],
                              "let" : [ ],
                              "relationship" : [ ],
                              "where" : {
                                 "localId" : "361",
                                 "locator" : "77:13-77:46",
                                 "type" : "Equivalent",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "362",
                                    "locator" : "77:19",
                                    "name" : "S",
                                    "type" : "AliasRef"
                                 }, {
                                    "localId" : "365",
                                    "type" : "ToConcept",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "363",
                                       "locator" : "77:23-77:46",
                                       "name" : "Left (qualifier value)",
                                       "type" : "CodeRef"
                                    }
                                 } ]
                              }
                           }
                        }
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "374",
                  "locator" : "80:5-80:95",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "373",
                     "locator" : "80:49-80:54",
                     "type" : "Start",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "370",
                        "locator" : "80:11-80:47",
                        "name" : "prevalenceInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "369",
                           "locator" : "80:11-80:24",
                           "name" : "LeftMastectomy",
                           "type" : "AliasRef"
                        } ]
                     }
                  }, {
                     "localId" : "371",
                     "locator" : "80:69-80:95",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "372",
                        "locator" : "80:76-80:95",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "379",
            "locator" : "82:1-84:114",
            "name" : "Left Mastectomy Procedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "379",
                  "s" : [ {
                     "value" : [ "","define ","\"Left Mastectomy Procedure\"",":\n  " ]
                  }, {
                     "r" : "394",
                     "s" : [ {
                        "s" : [ {
                           "r" : "380",
                           "s" : [ {
                              "r" : "385",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "385",
                                 "s" : [ {
                                    "r" : "383",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "383",
                                       "s" : [ {
                                          "value" : [ "[","Procedure",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Unilateral Mastectomy Left\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "385",
                                    "s" : [ {
                                       "value" : [ "isProcedurePerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","UnilateralMastectomyLeftPerformed" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "393",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "393",
                           "s" : [ {
                              "r" : "389",
                              "s" : [ {
                                 "r" : "388",
                                 "s" : [ {
                                    "r" : "386",
                                    "s" : [ {
                                       "value" : [ "UnilateralMastectomyLeftPerformed" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "388",
                                    "s" : [ {
                                       "value" : [ "performed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "389",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "393",
                              "value" : [ " ","ends on or before"," " ]
                           }, {
                              "r" : "390",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "391",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "394",
               "locator" : "83:3-84:114",
               "type" : "Query",
               "source" : [ {
                  "localId" : "380",
                  "locator" : "83:3-83:110",
                  "alias" : "UnilateralMastectomyLeftPerformed",
                  "expression" : {
                     "localId" : "385",
                     "locator" : "83:3-83:76",
                     "name" : "isProcedurePerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "383",
                        "locator" : "83:5-83:49",
                        "dataType" : "{http://hl7.org/fhir}Procedure",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "382",
                           "locator" : "83:19-83:46",
                           "name" : "Unilateral Mastectomy Left",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "393",
                  "locator" : "84:5-84:114",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "392",
                     "locator" : "84:70-84:73",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "389",
                        "locator" : "84:11-84:68",
                        "name" : "toInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "388",
                           "locator" : "84:11-84:53",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "387",
                              "path" : "performed",
                              "scope" : "UnilateralMastectomyLeftPerformed",
                              "type" : "Property"
                           } ]
                        } ]
                     }
                  }, {
                     "localId" : "390",
                     "locator" : "84:88-84:114",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "391",
                        "locator" : "84:95-84:114",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "398",
            "locator" : "86:1-88:107",
            "name" : "Bilateral Mastectomy Diagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "398",
                  "s" : [ {
                     "value" : [ "","define ","\"Bilateral Mastectomy Diagnosis\"",":\n  " ]
                  }, {
                     "r" : "410",
                     "s" : [ {
                        "s" : [ {
                           "r" : "399",
                           "s" : [ {
                              "r" : "402",
                              "s" : [ {
                                 "r" : "402",
                                 "s" : [ {
                                    "value" : [ "[","Condition",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"History of bilateral mastectomy\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","BilateralMastectomyHistory" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "409",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "409",
                           "s" : [ {
                              "r" : "405",
                              "s" : [ {
                                 "r" : "404",
                                 "s" : [ {
                                    "value" : [ "BilateralMastectomyHistory" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "405",
                                 "s" : [ {
                                    "value" : [ "prevalenceInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "409",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "406",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "407",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "410",
               "locator" : "87:3-88:107",
               "type" : "Query",
               "source" : [ {
                  "localId" : "399",
                  "locator" : "87:3-87:75",
                  "alias" : "BilateralMastectomyHistory",
                  "expression" : {
                     "localId" : "402",
                     "locator" : "87:3-87:48",
                     "dataType" : "{http://hl7.org/fhir}Condition",
                     "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                     "codeProperty" : "code",
                     "codeComparator" : "in",
                     "type" : "Retrieve",
                     "codes" : {
                        "localId" : "401",
                        "locator" : "87:15-87:47",
                        "name" : "History of bilateral mastectomy",
                        "preserve" : true,
                        "type" : "ValueSetRef"
                     },
                     "include" : [ ],
                     "codeFilter" : [ ],
                     "dateFilter" : [ ],
                     "otherFilter" : [ ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "409",
                  "locator" : "88:5-88:107",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "408",
                     "locator" : "88:61-88:66",
                     "type" : "Start",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "405",
                        "locator" : "88:11-88:59",
                        "name" : "prevalenceInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "404",
                           "locator" : "88:11-88:36",
                           "name" : "BilateralMastectomyHistory",
                           "type" : "AliasRef"
                        } ]
                     }
                  }, {
                     "localId" : "406",
                     "locator" : "88:81-88:107",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "407",
                        "locator" : "88:88-88:107",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "414",
            "locator" : "90:1-92:109",
            "name" : "Bilateral Mastectomy Procedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "414",
                  "s" : [ {
                     "value" : [ "","define ","\"Bilateral Mastectomy Procedure\"",":\n  " ]
                  }, {
                     "r" : "429",
                     "s" : [ {
                        "s" : [ {
                           "r" : "415",
                           "s" : [ {
                              "r" : "420",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "420",
                                 "s" : [ {
                                    "r" : "418",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "418",
                                       "s" : [ {
                                          "value" : [ "[","Procedure",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Bilateral Mastectomy\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "420",
                                    "s" : [ {
                                       "value" : [ "isProcedurePerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","BilateralMastectomyPerformed" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "428",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "428",
                           "s" : [ {
                              "r" : "424",
                              "s" : [ {
                                 "r" : "423",
                                 "s" : [ {
                                    "r" : "421",
                                    "s" : [ {
                                       "value" : [ "BilateralMastectomyPerformed" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "423",
                                    "s" : [ {
                                       "value" : [ "performed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "424",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "428",
                              "value" : [ " ","ends on or before"," " ]
                           }, {
                              "r" : "425",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "426",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "429",
               "locator" : "91:3-92:109",
               "type" : "Query",
               "source" : [ {
                  "localId" : "415",
                  "locator" : "91:3-91:99",
                  "alias" : "BilateralMastectomyPerformed",
                  "expression" : {
                     "localId" : "420",
                     "locator" : "91:3-91:70",
                     "name" : "isProcedurePerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "418",
                        "locator" : "91:5-91:43",
                        "dataType" : "{http://hl7.org/fhir}Procedure",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "417",
                           "locator" : "91:19-91:40",
                           "name" : "Bilateral Mastectomy",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "428",
                  "locator" : "92:5-92:109",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "427",
                     "locator" : "92:65-92:68",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "424",
                        "locator" : "92:11-92:63",
                        "name" : "toInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "423",
                           "locator" : "92:11-92:48",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "422",
                              "path" : "performed",
                              "scope" : "BilateralMastectomyPerformed",
                              "type" : "Property"
                           } ]
                        } ]
                     }
                  }, {
                     "localId" : "425",
                     "locator" : "92:83-92:109",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "426",
                        "locator" : "92:90-92:109",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "268",
            "locator" : "45:1-58:69",
            "name" : "Denominator Exclusions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "268",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator Exclusions\"",":\n  " ]
                  }, {
                     "r" : "269",
                     "s" : [ {
                        "r" : "270",
                        "s" : [ {
                           "r" : "271",
                           "s" : [ {
                              "r" : "272",
                              "s" : [ {
                                 "r" : "273",
                                 "s" : [ {
                                    "r" : "274",
                                    "s" : [ {
                                       "r" : "276",
                                       "s" : [ {
                                          "r" : "275",
                                          "s" : [ {
                                             "value" : [ "Hospice" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "276",
                                          "s" : [ {
                                             "value" : [ "\"Has Hospice Services\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    or " ]
                                    }, {
                                       "r" : "277",
                                       "s" : [ {
                                          "value" : [ "( " ]
                                       }, {
                                          "r" : "277",
                                          "s" : [ {
                                             "r" : "278",
                                             "s" : [ {
                                                "value" : [ "( " ]
                                             }, {
                                                "r" : "278",
                                                "s" : [ {
                                                   "r" : "279",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "318",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "318",
                                                         "s" : [ {
                                                            "value" : [ "\"Right Mastectomy Diagnosis\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n          or " ]
                                                }, {
                                                   "r" : "319",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "337",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "337",
                                                         "s" : [ {
                                                            "value" : [ "\"Right Mastectomy Procedure\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n      )" ]
                                             } ]
                                          }, {
                                             "value" : [ "\n        and " ]
                                          }, {
                                             "r" : "338",
                                             "s" : [ {
                                                "value" : [ "( " ]
                                             }, {
                                                "r" : "338",
                                                "s" : [ {
                                                   "r" : "339",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "376",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "376",
                                                         "s" : [ {
                                                            "value" : [ "\"Left Mastectomy Diagnosis\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n            or " ]
                                                }, {
                                                   "r" : "377",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "395",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "395",
                                                         "s" : [ {
                                                            "value" : [ "\"Left Mastectomy Procedure\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n        )" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n    )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    or " ]
                                 }, {
                                    "r" : "396",
                                    "s" : [ {
                                       "value" : [ "exists " ]
                                    }, {
                                       "r" : "411",
                                       "s" : [ {
                                          "value" : [ "\"Bilateral Mastectomy Diagnosis\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    or " ]
                              }, {
                                 "r" : "412",
                                 "s" : [ {
                                    "value" : [ "exists " ]
                                 }, {
                                    "r" : "430",
                                    "s" : [ {
                                       "value" : [ "\"Bilateral Mastectomy Procedure\"" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    or " ]
                           }, {
                              "r" : "432",
                              "s" : [ {
                                 "r" : "431",
                                 "s" : [ {
                                    "value" : [ "AIFrailLTCF" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "432",
                                 "s" : [ {
                                    "value" : [ "\"Is Age 66 or Older with Advanced Illness and Frailty\"" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "434",
                           "s" : [ {
                              "r" : "433",
                              "s" : [ {
                                 "value" : [ "AIFrailLTCF" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "434",
                              "s" : [ {
                                 "value" : [ "\"Is Age 66 or Older Living Long Term in a Nursing Home\"" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    or " ]
                     }, {
                        "r" : "436",
                        "s" : [ {
                           "r" : "435",
                           "s" : [ {
                              "value" : [ "PalliativeCare" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "436",
                           "s" : [ {
                              "value" : [ "\"Has Palliative Care in the Measurement Period\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "269",
               "locator" : "46:3-58:69",
               "type" : "Or",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "270",
                  "locator" : "46:3-57:74",
                  "type" : "Or",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "271",
                     "locator" : "46:3-56:73",
                     "type" : "Or",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "272",
                        "locator" : "46:3-55:46",
                        "type" : "Or",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "273",
                           "locator" : "46:3-54:46",
                           "type" : "Or",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "274",
                              "locator" : "46:3-53:5",
                              "type" : "Or",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "276",
                                 "locator" : "46:3-46:32",
                                 "name" : "Has Hospice Services",
                                 "libraryName" : "Hospice",
                                 "type" : "ExpressionRef"
                              }, {
                                 "localId" : "277",
                                 "locator" : "47:8-53:5",
                                 "type" : "And",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "278",
                                    "locator" : "47:10-49:7",
                                    "type" : "Or",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "279",
                                       "locator" : "47:12-47:50",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "318",
                                          "locator" : "47:19-47:50",
                                          "name" : "Right Mastectomy Diagnosis",
                                          "type" : "ExpressionRef"
                                       }
                                    }, {
                                       "localId" : "319",
                                       "locator" : "48:14-48:52",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "337",
                                          "locator" : "48:21-48:52",
                                          "name" : "Right Mastectomy Procedure",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "338",
                                    "locator" : "50:13-52:9",
                                    "type" : "Or",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "339",
                                       "locator" : "50:15-50:52",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "376",
                                          "locator" : "50:22-50:52",
                                          "name" : "Left Mastectomy Diagnosis",
                                          "type" : "ExpressionRef"
                                       }
                                    }, {
                                       "localId" : "377",
                                       "locator" : "51:16-51:53",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "395",
                                          "locator" : "51:23-51:53",
                                          "name" : "Left Mastectomy Procedure",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "localId" : "396",
                              "locator" : "54:8-54:46",
                              "type" : "Exists",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "411",
                                 "locator" : "54:15-54:46",
                                 "name" : "Bilateral Mastectomy Diagnosis",
                                 "type" : "ExpressionRef"
                              }
                           } ]
                        }, {
                           "localId" : "412",
                           "locator" : "55:8-55:46",
                           "type" : "Exists",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "430",
                              "locator" : "55:15-55:46",
                              "name" : "Bilateral Mastectomy Procedure",
                              "type" : "ExpressionRef"
                           }
                        } ]
                     }, {
                        "localId" : "432",
                        "locator" : "56:8-56:73",
                        "name" : "Is Age 66 or Older with Advanced Illness and Frailty",
                        "libraryName" : "AIFrailLTCF",
                        "type" : "ExpressionRef"
                     } ]
                  }, {
                     "localId" : "434",
                     "locator" : "57:8-57:74",
                     "name" : "Is Age 66 or Older Living Long Term in a Nursing Home",
                     "libraryName" : "AIFrailLTCF",
                     "type" : "ExpressionRef"
                  } ]
               }, {
                  "localId" : "436",
                  "locator" : "58:8-58:69",
                  "name" : "Has Palliative Care in the Measurement Period",
                  "libraryName" : "PalliativeCare",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "451",
            "locator" : "99:1-100:79",
            "name" : "October 1 Two Years Prior to the Measurement Period",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "451",
                  "s" : [ {
                     "value" : [ "","define ","\"October 1 Two Years Prior to the Measurement Period\"",":\n  " ]
                  }, {
                     "r" : "468",
                     "s" : [ {
                        "value" : [ "DateTime","(" ]
                     }, {
                        "r" : "452",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "452",
                           "s" : [ {
                              "r" : "453",
                              "s" : [ {
                                 "value" : [ "year from " ]
                              }, {
                                 "r" : "454",
                                 "s" : [ {
                                    "value" : [ "start of " ]
                                 }, {
                                    "r" : "455",
                                    "s" : [ {
                                       "value" : [ "\"Measurement Period\"" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "r" : "456",
                              "value" : [ " - ","2" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     }, {
                        "r" : "457",
                        "value" : [ ", ","10",", ","1",", ","0",", ","0",", ","0",", ","0",", ","0",")" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "468",
               "locator" : "100:3-100:79",
               "type" : "DateTime",
               "signature" : [ ],
               "year" : {
                  "localId" : "452",
                  "locator" : "100:12-100:56",
                  "type" : "Subtract",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "453",
                     "locator" : "100:13-100:51",
                     "precision" : "Year",
                     "type" : "DateTimeComponentFrom",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "454",
                        "locator" : "100:23-100:51",
                        "type" : "Start",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "455",
                           "locator" : "100:32-100:51",
                           "name" : "Measurement Period",
                           "type" : "ParameterRef"
                        }
                     }
                  }, {
                     "localId" : "456",
                     "locator" : "100:55",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2",
                     "type" : "Literal"
                  } ]
               },
               "month" : {
                  "localId" : "457",
                  "locator" : "100:59-100:60",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "10",
                  "type" : "Literal"
               },
               "day" : {
                  "localId" : "458",
                  "locator" : "100:63",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "1",
                  "type" : "Literal"
               },
               "hour" : {
                  "localId" : "459",
                  "locator" : "100:66",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "minute" : {
                  "localId" : "460",
                  "locator" : "100:69",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "second" : {
                  "localId" : "461",
                  "locator" : "100:72",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "millisecond" : {
                  "localId" : "462",
                  "locator" : "100:75",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "timezoneOffset" : {
                  "localId" : "470",
                  "type" : "ToDecimal",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "463",
                     "locator" : "100:78",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               }
            }
         }, {
            "localId" : "438",
            "locator" : "94:1-97:3",
            "name" : "Numerator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "438",
                  "s" : [ {
                     "value" : [ "","define ","\"Numerator\"",":\n  " ]
                  }, {
                     "r" : "439",
                     "s" : [ {
                        "value" : [ "exists " ]
                     }, {
                        "r" : "477",
                        "s" : [ {
                           "value" : [ "( " ]
                        }, {
                           "r" : "477",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "440",
                                 "s" : [ {
                                    "r" : "445",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "445",
                                       "s" : [ {
                                          "r" : "443",
                                          "s" : [ {
                                             "value" : [ "( " ]
                                          }, {
                                             "r" : "443",
                                             "s" : [ {
                                                "value" : [ "[","Observation",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Mammography\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          }, {
                                             "value" : [ " )" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "445",
                                          "s" : [ {
                                             "value" : [ "isDiagnosticStudyPerformed"," ( )" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ " ","Mammogram" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "476",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "476",
                                 "s" : [ {
                                    "r" : "449",
                                    "s" : [ {
                                       "r" : "448",
                                       "s" : [ {
                                          "r" : "446",
                                          "s" : [ {
                                             "value" : [ "Mammogram" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "448",
                                          "s" : [ {
                                             "value" : [ "effective" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "449",
                                       "s" : [ {
                                          "value" : [ "toInterval"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "476",
                                    "value" : [ " ","ends during day of"," " ]
                                 }, {
                                    "r" : "474",
                                    "s" : [ {
                                       "value" : [ "Interval[" ]
                                    }, {
                                       "r" : "471",
                                       "s" : [ {
                                          "value" : [ "\"October 1 Two Years Prior to the Measurement Period\"" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "472",
                                       "s" : [ {
                                          "value" : [ "end of " ]
                                       }, {
                                          "r" : "473",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "439",
               "locator" : "95:3-97:3",
               "type" : "Exists",
               "signature" : [ ],
               "operand" : {
                  "localId" : "477",
                  "locator" : "95:10-97:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "440",
                     "locator" : "95:12-95:88",
                     "alias" : "Mammogram",
                     "expression" : {
                        "localId" : "445",
                        "locator" : "95:12-95:78",
                        "name" : "isDiagnosticStudyPerformed",
                        "libraryName" : "Status",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "443",
                           "locator" : "95:14-95:45",
                           "dataType" : "{http://hl7.org/fhir}Observation",
                           "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation",
                           "codeProperty" : "code",
                           "codeComparator" : "in",
                           "type" : "Retrieve",
                           "codes" : {
                              "localId" : "442",
                              "locator" : "95:30-95:42",
                              "name" : "Mammography",
                              "preserve" : true,
                              "type" : "ValueSetRef"
                           },
                           "include" : [ ],
                           "codeFilter" : [ ],
                           "dateFilter" : [ ],
                           "otherFilter" : [ ]
                        } ]
                     }
                  } ],
                  "let" : [ ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "476",
                     "locator" : "96:7-96:158",
                     "precision" : "Day",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "475",
                        "locator" : "96:48-96:51",
                        "type" : "End",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "449",
                           "locator" : "96:13-96:46",
                           "name" : "toInterval",
                           "libraryName" : "QICoreCommon",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "448",
                              "locator" : "96:13-96:31",
                              "name" : "ToValue",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "447",
                                 "path" : "effective",
                                 "scope" : "Mammogram",
                                 "type" : "Property"
                              } ]
                           } ]
                        }
                     }, {
                        "localId" : "474",
                        "locator" : "96:67-96:158",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "471",
                           "locator" : "96:76-96:128",
                           "name" : "October 1 Two Years Prior to the Measurement Period",
                           "type" : "ExpressionRef"
                        },
                        "high" : {
                           "localId" : "472",
                           "locator" : "96:131-96:157",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "473",
                              "locator" : "96:138-96:157",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "479",
            "locator" : "102:1-103:21",
            "name" : "SDE Ethnicity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "479",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Ethnicity\"",":\n  " ]
                  }, {
                     "r" : "481",
                     "s" : [ {
                        "r" : "480",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "481",
                        "s" : [ {
                           "value" : [ "\"SDE Ethnicity\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "481",
               "locator" : "103:3-103:21",
               "name" : "SDE Ethnicity",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "483",
            "locator" : "105:1-106:17",
            "name" : "SDE Payer",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "483",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Payer\"",":\n  " ]
                  }, {
                     "r" : "485",
                     "s" : [ {
                        "r" : "484",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "485",
                        "s" : [ {
                           "value" : [ "\"SDE Payer\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "485",
               "locator" : "106:3-106:17",
               "name" : "SDE Payer",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "487",
            "locator" : "108:1-109:16",
            "name" : "SDE Race",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "487",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Race\"",":\n  " ]
                  }, {
                     "r" : "489",
                     "s" : [ {
                        "r" : "488",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "489",
                        "s" : [ {
                           "value" : [ "\"SDE Race\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "489",
               "locator" : "109:3-109:16",
               "name" : "SDE Race",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "491",
            "locator" : "111:1-112:15",
            "name" : "SDE Sex",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "491",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Sex\"",":\n  " ]
                  }, {
                     "r" : "493",
                     "s" : [ {
                        "r" : "492",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "493",
                        "s" : [ {
                           "value" : [ "\"SDE Sex\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "493",
               "locator" : "112:3-112:15",
               "name" : "SDE Sex",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         } ]
      }
   }
}" + } + ] + }, + "request": { + "method": "PUT", + "url": "Measure/BreastCancerScreeningFHIR" + } + } + ] +} diff --git a/cqf-fhir-utility/src/test/resources/org/opencds/cqf/fhir/utility/visitor/r4/Bundle-ecqm-qicore-2024-simplified.json b/cqf-fhir-utility/src/test/resources/org/opencds/cqf/fhir/utility/visitor/r4/Bundle-ecqm-qicore-2024-simplified.json new file mode 100644 index 000000000..6d2598a14 --- /dev/null +++ b/cqf-fhir-utility/src/test/resources/org/opencds/cqf/fhir/utility/visitor/r4/Bundle-ecqm-qicore-2024-simplified.json @@ -0,0 +1,5078 @@ +{ + "resourceType": "Bundle", + "id": "ecqm-content-qicore-2024-subset-simplified-bundle", + "type": "transaction", + "timestamp": "2022-10-21T15:18:28.504-04:00", + "entry": [ + { + "fullUrl": "http://hl7.org/fhir/us/cqfmeasures/Library/ecqm-update-2024-05-02|1.0.0", + "resource": { + "resourceType": "Library", + "id": "ecqm-update-2024-05-02", + "meta": { + "profile": [ + "http://hl7.org/fhir/uv/crmi/StructureDefinition/crmi-manifestlibrary" + ] + }, + "contained": [ + { + "resourceType": "Parameters", + "id": "exp-params", + "parameter": [ + { + "name": "system-version", + "valueUri": "http://snomed.info/sct|http://snomed.info/sct/731000124108/version/20230901" + }, + { + "name": "system-version", + "valueUri": "http://loinc.org|2.76" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/v3-ActCode|9.0.0" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender|3.0.0" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/CD2|2.0.1" + }, + { + "name": "system-version", + "valueUri": "urn:oid:2.16.840.1.113883.6.238|1.2" + }, + { + "name": "system-version", + "valueUri": "http://www.ama-assn.org/go/cpt|3.0.1" + }, + { + "name": "system-version", + "valueUri": "http://hl7.org/fhir/sid/cvx|4.0.0" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/HCPCS-all-codes|3.0.0" + }, + { + "name": "system-version", + "valueUri": "http://www.cms.gov/Medicare/Coding/HCPCSReleaseCodeSets|1.0.2" + }, + { + "name": "system-version", + "valueUri": "http://hl7.org/fhir/sid/icd-10-cm|2.0.1" + }, + { + "name": "system-version", + "valueUri": "http://www.cms.gov/Medicare/Coding/ICD10|2.0.1" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/icd9cm|2.0.1" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/v2-0895|2.2.0" + }, + { + "name": "system-version", + "valueUri": "http://www.nlm.nih.gov/research/umls/rxnorm|3.0.1" + }, + { + "name": "system-version", + "valueUri": "https://nahdo.org/sopt|1.0.1" + } + ] + } + ], + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expansionParameters", + "valueReference": { + "reference": "#exp-params" + } + } + ], + "url": "http://hl7.org/fhir/us/cqfmeasures/Library/ecqm-update-2024-05-02", + "identifier": [ + { + "use": "official", + "system": "http://example.org/fhir/cqi/ecqm/Library/Identifier", + "value": "eCQM Update 2024-05-02" + } + ], + "version": "1.0.0", + "name": "ECQMUpdate20240502", + "title": "eCQM Update 2024-05-02", + "status": "draft", + "experimental": true, + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "asset-collection" + } + ] + }, + "date": "2024-04-23", + "publisher": "Clinical Quality Information WG", + "contact": [ + { + "telecom": [ + { + "system": "url", + "value": "http://www.hl7.org/Special/committees/cqi" + } + ] + } + ], + "description": "This library is an example final draft of a version manifest (also referred to as an expansion profile) that specifies expansion rules for a set of value sets used for an example set of EP/EC measures.", + "useContext": [ + { + "code": { + "system": "http://terminology.hl7.org/CodeSystem/usage-context-type", + "code": "program" + }, + "valueCodeableConcept": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/quality-programs", + "code": "ep-ec", + "display": "EP/EC" + } + ] + } + }, + { + "code": { + "system": "http://terminology.hl7.org/CodeSystem/usage-context-type", + "code": "program" + }, + "valueCodeableConcept": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/quality-programs", + "code": "eh-cah", + "display": "EH/CAH" + } + ] + } + } + ], + "jurisdiction": [ + { + "coding": [ + { + "system": "urn:iso:std:iso:3166", + "code": "US" + } + ] + } + ], + "purpose": "This library is defined to illustrate a Version Manifest in final draft status, as it would look at the end of an eCQM Annual Update cycle, approved on April 23rd, 2024. The latest available version of code systems used at that time is specified to provide stability for value set expansion during the testing and implementation phase. Terminology.HL7.org, in particular, was version 5.5.0 at the time, and FHIR code system versions are chosen from that release.", + "approvalDate": "2024-04-23", + "lastReviewDate": "2024-04-23", + "relatedArtifact": [ + { + "type": "composed-of", + "display": "Measure Cervical Cancer ScreeningFHIR, 0.0.001", + "resource": "https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR|0.0.001" + }, + { + "type": "composed-of", + "display": "Measure Breast Cancer ScreeningFHIR, 0.0.001", + "resource": "https://madie.cms.gov/Measure/BreastCancerScreeningFHIR|0.0.001" + } + ] + }, + "request": { + "method": "PUT", + "url": "Library/ecqm-update-2024-05-02" + } + }, + { + "fullUrl": "https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Measure", + "id": "CervicalCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/publishable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/executable-measure-cqfm" + ] + }, + "contained": [ + { + "resourceType": "Library", + "id": "effective-data-requirements", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/observation-category", + "code": "laboratory", + "display": "laboratory" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428361000124107", + "display": "Discharge to home for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428371000124100", + "display": "Discharge to healthcare facility for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/observation-category", + "code": "survey", + "display": "survey" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "373066001", + "display": "Yes (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Cervical Cytology Within 3 Years" + }, + { + "url": "statement", + "valueString": "define \"Cervical Cytology Within 3 Years\":\n ( ( [Observation: \"Pap Test\"] ).isLaboratoryTestPerformed ( ) ) CervicalCytology\n where CervicalCytology.effective.latest ( ) during day of Interval[start of \"Measurement Period\" - 2 years, end of \"Measurement Period\"]\n and CervicalCytology.value is not null" + }, + { + "url": "displaySequence", + "valueInteger": 0 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "HPV Test Within 5 Years for Women Age 30 and Older" + }, + { + "url": "statement", + "valueString": "define \"HPV Test Within 5 Years for Women Age 30 and Older\":\n ( ( [Observation: \"HPV Test\"] ).isLaboratoryTestPerformed ( ) ) HPVTest\n where AgeInYearsAt(date from HPVTest.effective.latest()) >= 30\n and HPVTest.effective.latest ( ) during day of Interval[start of \"Measurement Period\" - 4 years, end of \"Measurement Period\"]\n and HPVTest.value is not null" + }, + { + "url": "displaySequence", + "valueInteger": 1 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Numerator" + }, + { + "url": "statement", + "valueString": "define \"Numerator\":\n exists \"Cervical Cytology Within 3 Years\"\n or exists \"HPV Test Within 5 Years for Women Age 30 and Older\"" + }, + { + "url": "displaySequence", + "valueInteger": 2 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Qualifying Encounters" + }, + { + "url": "statement", + "valueString": "define \"Qualifying Encounters\":\n ( ( [\"Encounter\": \"Office Visit\"]\n union [Encounter: \"Preventive Care Services Established Office Visit, 18 and Up\"]\n union [Encounter: \"Preventive Care Services Initial Office Visit, 18 and Up\"]\n union [Encounter: \"Home Healthcare Services\"]\n union [Encounter: \"Telephone Visits\"]\n union [Encounter: \"Virtual Encounter\"]\n ).isEncounterPerformed ( ) ) ValidEncounters\n where ValidEncounters.period.toInterval ( ) during day of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 3 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Initial Population" + }, + { + "url": "statement", + "valueString": "define \"Initial Population\":\n AgeInYearsAt(date from \n end of \"Measurement Period\"\n ) in Interval[24, 64]\n and Patient.gender = 'female'\n and exists \"Qualifying Encounters\"" + }, + { + "url": "displaySequence", + "valueInteger": 4 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator" + }, + { + "url": "statement", + "valueString": "define \"Denominator\":\n \"Initial Population\"" + }, + { + "url": "displaySequence", + "valueInteger": 5 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Hospice" + }, + { + "url": "name", + "valueString": "Has Hospice Services" + }, + { + "url": "statement", + "valueString": "define \"Has Hospice Services\":\n exists ((([Encounter: \"Encounter Inpatient\"]).isEncounterPerformed()) InpatientEncounter\n where (InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to home for hospice care (procedure)\"\n or InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to healthcare facility for hospice care (procedure)\"\n )\n and InpatientEncounter.period.toInterval() ends during day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Hospice Encounter\"]).isEncounterPerformed()) HospiceEncounter\n where HospiceEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Observation: \"Hospice care [Minimum Data Set]\"]).isAssessmentPerformed()) HospiceAssessment\n where HospiceAssessment.value ~ \"Yes (qualifier value)\"\n and HospiceAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([ServiceRequest: \"Hospice Care Ambulatory\"]).isInterventionOrder()) HospiceOrder\n where HospiceOrder.authoredOn.toInterval() during day of \"Measurement Period\"\n // and HospiceOrder.doNotPerform is not true\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-447\n )\n or exists ((([Procedure: \"Hospice Care Ambulatory\"]).isInterventionPerformed()) HospicePerformed\n where HospicePerformed.performed.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists (([Condition: \"Hospice Diagnosis\"]) HospiceCareDiagnosis\n where HospiceCareDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 6 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Absence of Cervix" + }, + { + "url": "statement", + "valueString": "define \"Absence of Cervix\":\n ( ( ( [Procedure: \"Hysterectomy with No Residual Cervix\"] ).isProcedurePerformed ( ) ) NoCervixProcedure\n where NoCervixProcedure.performed.toInterval ( ) ends on or before end of \"Measurement Period\"\n )\n union ( [Condition: \"Congenital or Acquired Absence of Cervix\"] NoCervixDiagnosis\n where NoCervixDiagnosis.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 7 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "PalliativeCare" + }, + { + "url": "name", + "valueString": "Has Palliative Care in the Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Palliative Care in the Measurement Period\":\n exists ((([Observation: \"Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)\"]).isAssessmentPerformed()) PalliativeAssessment\n where PalliativeAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ([Condition: \"Palliative Care Diagnosis\"] PalliativeDiagnosis\n where PalliativeDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Palliative Care Encounter\"]).isEncounterPerformed()) PalliativeEncounter\n where PalliativeEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Procedure: \"Palliative Care Intervention\"]).isInterventionPerformed()) PalliativeIntervention\n where PalliativeIntervention.performed.toInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 8 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator Exclusions" + }, + { + "url": "statement", + "valueString": "define \"Denominator Exclusions\":\n Hospice.\"Has Hospice Services\"\n or exists \"Absence of Cervix\"\n or PalliativeCare.\"Has Palliative Care in the Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 9 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isLaboratoryTestPerformed" + }, + { + "url": "statement", + "valueString": "//Laboratory Test, Performed\ndefine fluent function isLaboratoryTestPerformed(Obs List):\n Obs O\n where O.status in { 'final', 'amended', 'corrected' }\n and exists ( O.category ObservationCategory\n where ( ObservationCategory ) ~ \"laboratory\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 10 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "FHIRHelpers" + }, + { + "url": "name", + "valueString": "ToConcept" + }, + { + "url": "statement", + "valueString": "/*\n@description: Converts the given FHIR [CodeableConcept](https://hl7.org/fhir/datatypes.html#CodeableConcept) value to a CQL Concept.\n*/\ndefine function ToConcept(concept FHIR.CodeableConcept):\n if concept is null then\n null\n else\n System.Concept {\n codes: concept.coding C return ToCode(C),\n display: concept.text.value\n }" + }, + { + "url": "displaySequence", + "valueInteger": 11 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "latest" + }, + { + "url": "statement", + "valueString": "/*\n@description: Given an interval, returns the ending point if the interval has an ending boundary specified,\notherwise, returns the starting point\n*/\ndefine fluent function latest(choice Choice, Interval> ):\n (choice.toInterval()) period\n return\n if (period.\"hasEnd\"()) then end of period\n else start of period" + }, + { + "url": "displaySequence", + "valueInteger": 12 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isEncounterPerformed" + }, + { + "url": "statement", + "valueString": "//Encounter, Performed\n//General usage unless required otherwise by measure intent (e.g., follow-up encounters)\ndefine fluent function isEncounterPerformed(Enc List):\n Enc E\n where E.status in {'finished', 'arrived', 'triaged', 'in-progress', 'onleave'}" + }, + { + "url": "displaySequence", + "valueInteger": 13 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "toInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval\n@comment: Normalizes a choice type of DateTime, Quanitty, Interval, or Interval types\nto an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible\nrepresentations for timing-valued elements in QICore, allowing this function to be used across any resource.\nThe input can be provided as a DateTime, Quantity, Interval or Interval.\nThe intent of this function is to provide a clear and concise mechanism to treat single\nelements that have multiple possible representations as intervals so that logic doesn't have to account\nfor the variability. More complex calculations (such as medication request period or dispense period\ncalculation) need specific guidance and consideration. That guidance may make use of this function, but\nthe focus of this function is on single element calculations where the semantics are unambiguous.\nIf the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.\nIf the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,\nand the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.\nIf the input is a DateTime Interval, the result is the input.\nIf the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result\nis a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending\nimmediately before one year later than the date the patient turned the age given as the end of the quantity interval.\nIf the input is a Timing, an error will be thrown indicating that Timing calculations are not implemented. Any other input will reslt in a null DateTime Interval\n*/\ndefine fluent function toInterval(choice Choice, Interval, Timing>):\n case\n\t when choice is DateTime then\n \tInterval[choice as DateTime, choice as DateTime]\n\t\twhen choice is Interval then\n \t\tchoice as Interval\n\t\twhen choice is Quantity then\n\t\t Interval[Patient.birthDate + (choice as Quantity),\n\t\t\t Patient.birthDate + (choice as Quantity) + 1 year)\n\t\twhen choice is Interval then\n\t\t Interval[Patient.birthDate + (choice.low as Quantity),\n\t\t\t Patient.birthDate + (choice.high as Quantity) + 1 year)\n\t\twhen choice is Timing then\n Message(null, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a Timing value is not supported') as Interval\n\t\telse\n\t\t\tnull as Interval\n\tend" + }, + { + "url": "displaySequence", + "valueInteger": 14 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isAssessmentPerformed" + }, + { + "url": "statement", + "valueString": "//This library contains functions that are based on QDM 5.6 to QICore 4.1.1 March 2023 (https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns---QICore-v4.1.1). The functions may appear similar to some QICoreCommon functions but different in that they have constraints that are relevant for measures authored by NCQA.\n\n//Assessment, Performed\ndefine fluent function isAssessmentPerformed(Obs List):\n Obs O\n where O.status in { 'final', 'amended', 'corrected' }\n and exists ( O.category ObservationCategory\n where ( ObservationCategory ) ~ \"survey\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 15 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionOrder" + }, + { + "url": "statement", + "valueString": "//Intervention, Order: active and completed only \ndefine fluent function isInterventionOrder(ServiceRequest List):\n ServiceRequest S\n where S.status in { 'active', 'completed' }\n and S.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 16 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionPerformed" + }, + { + "url": "statement", + "valueString": "//Intervention, Performed\ndefine fluent function isInterventionPerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 17 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "prevalenceInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Returns an interval representing the normalized prevalence period of a given Condition.\n@comment: Uses the ToInterval and ToAbatementInterval functions to determine the widest potential interval from\nonset to abatement as specified in the given Condition. If the condition is active, or has an abatement date the resulting \ninterval will have a closed ending boundary. Otherwise, the resulting interval will have an open ending boundary.\n*/\ndefine fluent function prevalenceInterval(condition Condition):\nif condition.clinicalStatus ~ \"active\"\n or condition.clinicalStatus ~ \"recurrence\"\n or condition.clinicalStatus ~ \"relapse\" then\n Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()]\nelse\n (end of condition.abatementInterval()) abatementDate\n return if abatementDate is null then\n Interval[start of condition.onset.toInterval(), abatementDate)\n else\n Interval[start of condition.onset.toInterval(), abatementDate]" + }, + { + "url": "displaySequence", + "valueInteger": 18 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isProcedurePerformed" + }, + { + "url": "statement", + "valueString": "//Procedure, Performed\ndefine fluent function isProcedurePerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 19 + } + ] + } + ], + "name": "EffectiveDataRequirements", + "status": "active", + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "module-definition" + } + ] + }, + "relatedArtifact": [ + { + "type": "depends-on", + "display": "Library Status", + "resource": "Library/Status|1.8.000" + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "Library/FHIRHelpers|4.4.000" + }, + { + "type": "depends-on", + "display": "Library QICoreCommon", + "resource": "Library/QICoreCommon|2.1.000" + }, + { + "type": "depends-on", + "display": "Library Hospice", + "resource": "Library/Hospice|6.12.000" + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": "Library/PalliativeCare|1.11.000" + }, + { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": "http://terminology.hl7.org/CodeSystem/observation-category" + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, + { + "type": "depends-on", + "display": "Value set Pap Test", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" + }, + { + "type": "depends-on", + "display": "Value set HPV Test", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" + }, + { + "type": "depends-on", + "display": "Value set Office Visit", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Established Office Visit, 18 and Up", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Initial Office Visit, 18 and Up", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + }, + { + "type": "depends-on", + "display": "Value set Home Healthcare Services", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + }, + { + "type": "depends-on", + "display": "Value set Telephone Visits", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + }, + { + "type": "depends-on", + "display": "Value set Virtual Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + }, + { + "type": "depends-on", + "display": "Value set Encounter Inpatient", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + }, + { + "type": "depends-on", + "display": "Value set Hospice Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + }, + { + "type": "depends-on", + "display": "Value set Hospice Care Ambulatory", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + }, + { + "type": "depends-on", + "display": "Value set Hospice Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + }, + { + "type": "depends-on", + "display": "Value set Hysterectomy with No Residual Cervix", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + }, + { + "type": "depends-on", + "display": "Value set Congenital or Acquired Absence of Cervix", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Intervention", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + } + ], + "dataRequirement": [ + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ] + }, + { + "path": "value" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ] + } + ] + }, + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + ] + } + ] + } + ], + "extension": [ + { + "id": "effective-data-requirements", + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-effectiveDataRequirements", + "valueReference": { + "reference": "#effective-data-requirements" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + }, + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlOptions", + "valueReference": { + "reference": "Measure/cql-options-test" + } + }, + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expansionParameters", + "valueReference": { + "reference": "#exp-params-test-absent" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-inputParameters", + "valueReference": { + "reference": "Library/input-parameters-test" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-component", + "valueRelatedArtifact": { + "resource": "Library/cqfm-component-test", + "type": "composed-of" + } + } + ], + "url": "https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR", + "identifier": [ + { + "use": "usual", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "short-name" + } + ] + }, + "system": "https://madie.cms.gov/measure/shortName", + "value": "CMS124FHIR" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-independent" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:3be5df74-24e1-46ed-b899-6e98b9e3760b" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-specific" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:d66e7255-e320-4d80-b28a-091f041ea7e0" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "publisher" + } + ] + }, + "system": "https://madie.cms.gov/measure/cmsId", + "value": "124FHIR", + "assigner": { + "display": "CMS" + } + } + ], + "version": "0.0.001", + "name": "CervicalCancerScreeningFHIR", + "title": "Cervical Cancer ScreeningFHIR", + "status": "active", + "experimental": false, + "date": "2024-07-09T14:53:56+00:00", + "publisher": "National Committee for Quality Assurance", + "contact": [ + { + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "description": "Percentage of women 21-64 years of age who were screened for cervical cancer using either of the following criteria: - Women age 21-64 who had cervical cytology performed within the last 3 years - Women age 30-64 who had cervical human papillomavirus (HPV) testing performed within the last 5 years", + "purpose": "UNKNOWN", + "usage": "To ensure the measure is only looking for a cervical cytology test only after a woman turns 21 years of age, the youngest age in the initial population is 23. Please note the measure may include screenings performed outside the age range of patients referenced in the initial population. Screenings that occur prior to the measurement period are valid to meet measure criteria. Evidence of hrHPV testing within the last 5 years also captures patients who had cotesting; therefore additional methods to identify cotesting are not necessary. This eCQM is a patient-based measure. This FHIR-based measure has been derived from the QDM-based measure: CMS124v13. Please refer to the HL7 QI-Core Implementation Guide (https://hl7.org/fhir/us/qicore/STU4.1.1/) for more information on QI-Core and mapping recommendations from QDM to QI-Core 4.1.1 (https://hl7.org/fhir/us/qicore/STU4.1.1/qdm-to-qicore.html).", + "copyright": "This Physician Performance Measure (Measure) and related data specifications are owned and were developed by the National Committee for Quality Assurance (NCQA). NCQA is not responsible for any use of the Measure. NCQA makes no representations, warranties, or endorsement about the quality of any organization or physician that uses or reports performance measures and NCQA has no liability to anyone who relies on such measures or specifications. NCQA holds a copyright in the Measure. The Measure can be reproduced and distributed, without modification, for noncommercial purposes (e.g., use by healthcare providers in connection with their practices) without obtaining approval from NCQA. Commercial use is defined as the sale, licensing, or distribution of the Measure for commercial gain, or incorporation of the Measure into a product or service that is sold, licensed or distributed for commercial gain. All commercial uses or requests for modification must be approved by NCQA and are subject to a license at the discretion of NCQA. (C) 2012-2021 National Committee for Quality Assurance. All Rights Reserved. Limited proprietary coding is contained in the Measure specifications for user convenience. Users of proprietary code sets should obtain all necessary licenses from the owners of the code sets. NCQA disclaims all liability for use or accuracy of any third party codes contained in the specifications. CPT(R) contained in the Measure specifications is copyright 2004-2021 American Medical Association. LOINC(R) copyright 2004-2021 Regenstrief Institute, Inc. This material contains SNOMED Clinical Terms(R) (SNOMED CT[R]) copyright 2004-2021 International Health Terminology Standards Development Organisation. ICD-10 copyright 2021 World Health Organization. All Rights Reserved.", + "effectivePeriod": { + "start": "2025-01-01", + "end": "2025-12-31" + }, + "author": [ + { + "name": "National Committee for Quality Assurance", + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "library": [ + "https://madie.cms.gov/Library/CervicalCancerScreeningFHIR" + ], + "supplementalData": [ + { + "criteria": { + "reference": "Library/supplemental-criteria-reference-test" + } + } + ], + "disclaimer": "The performance Measure is not a clinical guideline and does not establish a standard of medical care, and has not been tested for all potential applications. THE MEASURE AND SPECIFICATIONS ARE PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. Due to technical limitations, registered trademarks are indicated by (R) or [R] and unregistered trademarks are indicated by (TM) or [TM].", + "rationale": "All women are at risk for cervical cancer. In 2020, an estimated 13,800 women were diagnosed with cervical cancer in the U.S., resulting in an estimated 4,290 deaths (National Cancer Institute, 2020). Screening can identify precancerous lesions and can detect invasive cancer early, when treatment is more likely to be successful (American Cancer Society, 2020).", + "clinicalRecommendationStatement": "US Preventive Services Task Force (USPSTF) (2018) \"The USPSTF recommends screening for cervical cancer every 3 years with cervical cytology alone in women aged 21 to 29 years. For women aged 30 to 65 years, the USPSTF recommends screening every 3 years with cervical cytology alone, every 5 years with high-risk human papillomavirus (hrHPV) testing alone, or every 5 years with hrHPV testing in combination with cytology (cotesting) (A recommendation)\" \"The USPSTF recommends against screening for cervical cancer in women older than 65 years who have had adequate prior screening and are not otherwise at high risk for cervical cancer. (D recommendation)\" \"The USPSTF recommends against screening for cervical cancer in women younger than 21 years. (D recommendation)\" \"The USPSTF recommends against screening for cervical cancer in women who have had a hysterectomy with removal of the cervix and do not have a history of a high-grade precancerous lesion (ie, cervical intraepithelial neoplasia [CIN] grade 2 or 3) or cervical cancer. (D recommendation)\"", + "group": [ + { + "id": "64d29f68f9c3ae6981ef507d", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-scoring", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-scoring", + "code": "proportion", + "display": "Proportion" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-populationBasis", + "valueCode": "boolean" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-type", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-type", + "code": "process", + "display": "Process" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-rateAggregation", + "valueCode": "None" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-improvementNotation", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-improvement-notation", + "code": "decrease", + "display": "increase" + } + ] + } + } + ], + "population": [ + { + "id": "0CB398EC-F7C3-4882-98FF-D9E0E3E62B4F", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "initial-population", + "display": "Initial Population" + } + ] + }, + "description": "Women 24-64 years of age by the end of the measurement period with a visit during the measurement period", + "criteria": { + "language": "text/cql-identifier", + "expression": "Initial Population" + } + }, + { + "id": "C02AA51E-4436-4034-A67F-DB42C22EB337", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator", + "display": "Denominator" + } + ] + }, + "description": "Equals Initial Population", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator" + } + }, + { + "id": "2EF6ABDF-E416-44B8-928B-DCC7D7C55860", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator-exclusion", + "display": "Denominator Exclusion" + } + ] + }, + "description": "Exclude patients who are in hospice care for any part of the measurement period. Women who had a hysterectomy with no residual cervix or a congenital absence of cervix. Exclude patients receiving palliative care for any part of the measurement period.", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator Exclusions" + } + }, + { + "id": "56088E3D-0DEE-43D2-9866-1F38ACB030CB", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "numerator", + "display": "Numerator" + } + ] + }, + "description": "Women with one or more screenings for cervical cancer. Appropriate screenings are defined by any one of the following criteria: - Cervical cytology performed during the measurement period or the two years prior to the measurement period for women who are at least 21 years old at the time of the test. - Cervical human papillomavirus (HPV) testing performed during the measurement period or the four years prior to the measurement period for women who are 30 years or older at the time of the test.", + "criteria": { + "language": "text/cql-identifier", + "expression": "Numerator" + } + }, + { + "criteria": { "reference": "Library/population-criteria-test" } + } + ], + "stratifier": [ + { + "criteria": { "reference": "Library/stratifier-criteria-test" } + }, + { + "component": { + "criteria": { + "reference": "Library/stratifier-component-criteria-test" + } + } + } + ] + } + ] + }, + "request": { + "method": "PUT", + "url": "Measure/CervicalCancerScreeningFHIR" + } + }, + { + "fullUrl": "https://madie.cms.gov/Library/CervicalCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Library", + "id": "CervicalCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-library-cqfm" + ] + }, + "language": "en", + "contained": [ + { + "resourceType": "Parameters", + "id": "options", + "parameter": [ + { + "name": "translatorVersion", + "valueString": "3.10.0" + }, + { + "name": "option", + "valueString": "EnableAnnotations" + }, + { + "name": "option", + "valueString": "EnableLocators" + }, + { + "name": "option", + "valueString": "DisableListDemotion" + }, + { + "name": "option", + "valueString": "DisableListPromotion" + }, + { + "name": "format", + "valueString": "XML" + }, + { + "name": "format", + "valueString": "JSON" + }, + { + "name": "analyzeDataRequirements", + "valueBoolean": true + }, + { + "name": "collapseDataRequirements", + "valueBoolean": true + }, + { + "name": "compatibilityLevel", + "valueString": "1.5" + }, + { + "name": "enableCqlOnly", + "valueBoolean": false + }, + { + "name": "errorLevel", + "valueString": "Info" + }, + { + "name": "signatureLevel", + "valueString": "None" + }, + { + "name": "validateUnits", + "valueBoolean": true + }, + { + "name": "verifyOnly", + "valueBoolean": false + } + ] + } + ], + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlOptions", + "valueReference": { + "reference": "#options" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } + ], + "url": "https://madie.cms.gov/Library/CervicalCancerScreeningFHIR", + "identifier": [ + { + "use": "official", + "system": "https://madie.cms.gov/login", + "value": "CervicalCancerScreeningFHIR" + } + ], + "version": "0.0.001", + "name": "CervicalCancerScreeningFHIR", + "title": "CervicalCancerScreeningFHIR", + "status": "active", + "experimental": false, + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } + ] + }, + "date": "2024-05-16T13:50:20+00:00", + "description": "CervicalCancerScreeningFHIR", + "relatedArtifact": [ + { + "type": "depends-on", + "display": "QICore model information", + "resource": "http://hl7.org/fhir/Library/QICore-ModelInfo" + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://ecqi.healthit.gov/ecqms/Library/FHIRHelpers|4.4.000" + }, + { + "type": "depends-on", + "display": "Library Hospice", + "resource": "http://ecqi.healthit.gov/ecqms/Library/Hospice|6.12.000" + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": "http://ecqi.healthit.gov/ecqms/Library/PalliativeCare|1.11.000" + }, + { + "type": "depends-on", + "display": "Library Status", + "resource": "http://ecqi.healthit.gov/ecqms/Library/Status|1.8.000" + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, + { + "type": "depends-on", + "display": "Code system AdministrativeGender", + "resource": "http://hl7.org/fhir/administrative-gender" + }, + { + "type": "depends-on", + "display": "Value set Congenital or Acquired Absence of Cervix", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + }, + { + "type": "depends-on", + "display": "Value set Hysterectomy with No Residual Cervix", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + }, + { + "type": "depends-on", + "display": "Value set Encounter Inpatient", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + }, + { + "type": "depends-on", + "display": "Value set Payer Type", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "Qualifying Encounters", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Absence of Cervix", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Cervical Cytology Within 3 Years", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "HPV Test Within 5 Years for Women Age 30 and Older", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "SDE Ethnicity", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Payer", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "SDE Race", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Sex", + "use": "out", + "min": 0, + "max": "1", + "type": "Coding" + } + ], + "dataRequirement": [ + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ], + "mustSupport": ["ethnicity", "race"] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ] + }, + { + "path": "value" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ] + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Coverage", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-coverage" + ], + "mustSupport": ["type", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + ] + } + ], + "content": [ + { + "contentType": "text/cql", + "data": "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" + }, + { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1" localId="0">
   <annotation translatorVersion="3.10.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" signatureLevel="None" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:s r="587">
         <a:s>library CervicalCancerScreeningFHIR version '0.0.001'</a:s>
      </a:s>
   </annotation>
   <identifier id="CervicalCancerScreeningFHIR" system="http://ecqi.healthit.gov/ecqms" version="0.0.001"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localId="1" localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="206" locator="3:1-3:28" localIdentifier="QICore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="206">
               <a:s>using </a:s>
               <a:s>
                  <a:s>QICore</a:s>
               </a:s>
               <a:s> version '4.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="207" locator="5:1-5:56" localIdentifier="FHIRHelpers" path="http://ecqi.healthit.gov/ecqms/FHIRHelpers" version="4.4.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="207">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.4.000' called FHIRHelpers</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="208" locator="6:1-6:61" localIdentifier="SDE" path="http://ecqi.healthit.gov/ecqms/SupplementalDataElements" version="3.5.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="208">
               <a:s>include </a:s>
               <a:s>
                  <a:s>SupplementalDataElements</a:s>
               </a:s>
               <a:s> version '3.5.000' called SDE</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="209" locator="7:1-7:58" localIdentifier="QICoreCommon" path="http://ecqi.healthit.gov/ecqms/QICoreCommon" version="2.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="209">
               <a:s>include </a:s>
               <a:s>
                  <a:s>QICoreCommon</a:s>
               </a:s>
               <a:s> version '2.1.000' called QICoreCommon</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="210" locator="8:1-8:49" localIdentifier="Hospice" path="http://ecqi.healthit.gov/ecqms/Hospice" version="6.12.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="210">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Hospice</a:s>
               </a:s>
               <a:s> version '6.12.000' called Hospice</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="211" locator="9:1-9:63" localIdentifier="PalliativeCare" path="http://ecqi.healthit.gov/ecqms/PalliativeCare" version="1.11.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="211">
               <a:s>include </a:s>
               <a:s>
                  <a:s>PalliativeCare</a:s>
               </a:s>
               <a:s> version '1.11.000' called PalliativeCare</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="212" locator="10:1-10:46" localIdentifier="Status" path="http://ecqi.healthit.gov/ecqms/Status" version="1.8.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="212">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Status</a:s>
               </a:s>
               <a:s> version '1.8.000' called Status</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <parameters>
      <def localId="223" locator="23:1-23:49" name="Measurement Period" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="223">
               <a:s>parameter &quot;Measurement Period&quot; </a:s>
               <a:s r="224">
                  <a:s>Interval&lt;</a:s>
                  <a:s r="225">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
            </a:s>
         </annotation>
         <parameterTypeSpecifier localId="224" locator="23:32-23:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="225" locator="23:41-23:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <valueSets>
      <def localId="213" locator="12:1-12:132" name="Congenital or Acquired Absence of Cervix" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="213">
               <a:s>valueset &quot;Congenital or Acquired Absence of Cervix&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="214" locator="13:1-13:116" name="Home Healthcare Services" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="214">
               <a:s>valueset &quot;Home Healthcare Services&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="215" locator="14:1-14:100" name="HPV Test" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="215">
               <a:s>valueset &quot;HPV Test&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="216" locator="15:1-15:128" name="Hysterectomy with No Residual Cervix" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="216">
               <a:s>valueset &quot;Hysterectomy with No Residual Cervix&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="217" locator="16:1-16:104" name="Office Visit" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="217">
               <a:s>valueset &quot;Office Visit&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="218" locator="17:1-17:109" name="Virtual Encounter" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="218">
               <a:s>valueset &quot;Virtual Encounter&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="219" locator="18:1-18:100" name="Pap Test" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="219">
               <a:s>valueset &quot;Pap Test&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="220" locator="19:1-19:152" name="Preventive Care Services Established Office Visit, 18 and Up" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="220">
               <a:s>valueset &quot;Preventive Care Services Established Office Visit, 18 and Up&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="221" locator="20:1-20:148" name="Preventive Care Services Initial Office Visit, 18 and Up" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="221">
               <a:s>valueset &quot;Preventive Care Services Initial Office Visit, 18 and Up&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="222" locator="21:1-21:108" name="Telephone Visits" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="222">
               <a:s>valueset &quot;Telephone Visits&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080'</a:s>
            </a:s>
         </annotation>
      </def>
   </valueSets>
   <contexts>
      <def localId="229" locator="25:1-25:15" name="Patient"/>
   </contexts>
   <statements>
      <def localId="227" locator="25:1-25:15" name="Patient" context="Patient">
         <expression localId="228" xsi:type="SingletonFrom">
            <operand localId="226" locator="25:1-25:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="254" locator="34:1-42:82" name="Qualifying Encounters" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="254">
               <a:s>define &quot;Qualifying Encounters&quot;:
  </a:s>
               <a:s r="304">
                  <a:s>
                     <a:s r="255">
                        <a:s r="287">
                           <a:s>( </a:s>
                           <a:s r="287">
                              <a:s r="286">
                                 <a:s>( </a:s>
                                 <a:s r="286">
                                    <a:s r="280">
                                       <a:s r="275">
                                          <a:s r="269">
                                             <a:s r="264">
                                                <a:s r="258">
                                                   <a:s>[&quot;Encounter&quot;: </a:s>
                                                   <a:s>
                                                      <a:s>&quot;Office Visit&quot;</a:s>
                                                   </a:s>
                                                   <a:s>]</a:s>
                                                </a:s>
                                                <a:s>
      union </a:s>
                                                <a:s r="262">
                                                   <a:s>[Encounter: </a:s>
                                                   <a:s>
                                                      <a:s>&quot;Preventive Care Services Established Office Visit, 18 and Up&quot;</a:s>
                                                   </a:s>
                                                   <a:s>]</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
      union </a:s>
                                             <a:s r="267">
                                                <a:s>[Encounter: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Preventive Care Services Initial Office Visit, 18 and Up&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
      union </a:s>
                                          <a:s r="272">
                                             <a:s>[Encounter: </a:s>
                                             <a:s>
                                                <a:s>&quot;Home Healthcare Services&quot;</a:s>
                                             </a:s>
                                             <a:s>]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>
      union </a:s>
                                       <a:s r="278">
                                          <a:s>[Encounter: </a:s>
                                          <a:s>
                                             <a:s>&quot;Telephone Visits&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
      union </a:s>
                                    <a:s r="283">
                                       <a:s>[Encounter: </a:s>
                                       <a:s>
                                          <a:s>&quot;Virtual Encounter&quot;</a:s>
                                       </a:s>
                                       <a:s>]</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
  )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="287">
                                 <a:s>isEncounterPerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> ValidEncounters</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="302">
                     <a:s>where </a:s>
                     <a:s r="302">
                        <a:s r="291">
                           <a:s r="290">
                              <a:s r="288">
                                 <a:s>ValidEncounters</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="290">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="291">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="302"> during day of </a:s>
                        <a:s r="301">
                           <a:s>&quot;Measurement Period&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="304" locator="35:3-42:82" xsi:type="Query">
            <source localId="255" locator="35:3-41:46" alias="ValidEncounters">
               <expression localId="287" locator="35:3-41:30" name="isEncounterPerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="286" locator="35:5-41:3" xsi:type="Union">
                     <operand localId="275" locator="35:7-38:51" xsi:type="Union">
                        <operand localId="264" locator="35:7-36:87" xsi:type="Union">
                           <operand localId="258" locator="35:7-35:35" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="257" locator="35:21-35:34" name="Office Visit" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                           <operand localId="262" locator="36:13-36:87" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="261" locator="36:25-36:86" name="Preventive Care Services Established Office Visit, 18 and Up" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                        </operand>
                        <operand localId="274" xsi:type="Union">
                           <operand localId="267" locator="37:13-37:83" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="266" locator="37:25-37:82" name="Preventive Care Services Initial Office Visit, 18 and Up" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                           <operand localId="272" locator="38:13-38:51" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="271" locator="38:25-38:50" name="Home Healthcare Services" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="285" xsi:type="Union">
                        <operand localId="278" locator="39:13-39:43" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="277" locator="39:25-39:42" name="Telephone Visits" preserve="true" xsi:type="ValueSetRef"/>
                        </operand>
                        <operand localId="283" locator="40:13-40:44" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="282" locator="40:25-40:43" name="Virtual Encounter" preserve="true" xsi:type="ValueSetRef"/>
                        </operand>
                     </operand>
                  </operand>
               </expression>
            </source>
            <where localId="302" locator="42:5-42:82" precision="Day" xsi:type="IncludedIn">
               <operand localId="291" locator="42:11-42:47" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                  <operand localId="292" xsi:type="As">
                     <operand localId="290" locator="42:11-42:32" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="289" path="period" scope="ValidEncounters" xsi:type="Property"/>
                     </operand>
                     <asTypeSpecifier localId="293" xsi:type="ChoiceTypeSpecifier">
                        <choice localId="294" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                        <choice localId="295" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        <choice localId="296" xsi:type="IntervalTypeSpecifier">
                           <pointType localId="297" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                        </choice>
                        <choice localId="298" xsi:type="IntervalTypeSpecifier">
                           <pointType localId="299" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        </choice>
                        <choice localId="300" name="fhir:Timing" xsi:type="NamedTypeSpecifier"/>
                     </asTypeSpecifier>
                  </operand>
               </operand>
               <operand localId="301" locator="42:63-42:82" name="Measurement Period" xsi:type="ParameterRef"/>
            </where>
         </expression>
      </def>
      <def localId="231" locator="27:1-32:38" name="Initial Population" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="231">
               <a:s>define &quot;Initial Population&quot;:
  </a:s>
               <a:s r="232">
                  <a:s r="233">
                     <a:s r="246">
                        <a:s r="242">
                           <a:s>AgeInYearsAt(</a:s>
                           <a:s r="234">
                              <a:s>date from 
    </a:s>
                              <a:s r="235">
                                 <a:s>end of </a:s>
                                 <a:s r="236">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
  )</a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="245">
                           <a:s r="243">Interval[24, 64]</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    and </a:s>
                     <a:s r="247">
                        <a:s r="250">
                           <a:s r="248">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="250">
                              <a:s>gender</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="251">
                           <a:s>'female'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    and </a:s>
                  <a:s r="252">
                     <a:s>exists </a:s>
                     <a:s r="305">
                        <a:s>&quot;Qualifying Encounters&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="232" locator="28:3-32:38" xsi:type="And">
            <operand localId="233" locator="28:3-31:33" xsi:type="And">
               <operand localId="246" locator="28:3-30:23" xsi:type="In">
                  <operand localId="242" locator="28:3-30:3" precision="Year" xsi:type="CalculateAgeAt">
                     <operand localId="241" path="value" xsi:type="Property">
                        <source localId="240" path="birthDate" xsi:type="Property">
                           <source localId="239" name="Patient" xsi:type="ExpressionRef"/>
                        </source>
                     </operand>
                     <operand localId="234" locator="28:16-29:31" xsi:type="DateFrom">
                        <operand localId="235" locator="29:5-29:31" xsi:type="End">
                           <operand localId="236" locator="29:12-29:31" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="245" locator="30:8-30:23" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="243" locator="30:17-30:18" valueType="t:Integer" value="24" xsi:type="Literal"/>
                     <high localId="244" locator="30:21-30:22" valueType="t:Integer" value="64" xsi:type="Literal"/>
                  </operand>
               </operand>
               <operand localId="247" locator="31:9-31:33" xsi:type="Equal">
                  <operand localId="250" locator="31:9-31:22" path="value" xsi:type="Property">
                     <source localId="249" path="gender" xsi:type="Property">
                        <source localId="248" locator="31:9-31:15" name="Patient" xsi:type="ExpressionRef"/>
                     </source>
                  </operand>
                  <operand localId="251" locator="31:26-31:33" valueType="t:String" value="female" xsi:type="Literal"/>
               </operand>
            </operand>
            <operand localId="252" locator="32:9-32:38" xsi:type="Exists">
               <operand localId="305" locator="32:16-32:38" name="Qualifying Encounters" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="307" locator="44:1-45:22" name="Denominator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="307">
               <a:s>define &quot;Denominator&quot;:
  </a:s>
               <a:s r="308">
                  <a:s>&quot;Initial Population&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="308" locator="45:3-45:22" name="Initial Population" xsi:type="ExpressionRef"/>
      </def>
      <def localId="317" locator="56:1-62:5" name="Absence of Cervix" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="317">
               <a:s>define &quot;Absence of Cervix&quot;:
  </a:s>
               <a:s r="355">
                  <a:s r="332">
                     <a:s>( </a:s>
                     <a:s r="332">
                        <a:s>
                           <a:s r="318">
                              <a:s r="323">
                                 <a:s>( </a:s>
                                 <a:s r="323">
                                    <a:s r="321">
                                       <a:s>( </a:s>
                                       <a:s r="321">
                                          <a:s>[Procedure: </a:s>
                                          <a:s>
                                             <a:s>&quot;Hysterectomy with No Residual Cervix&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                       <a:s> )</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="323">
                                       <a:s>isProcedurePerformed ( )</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s> NoCervixProcedure</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="331">
                           <a:s>where </a:s>
                           <a:s r="331">
                              <a:s r="327">
                                 <a:s r="326">
                                    <a:s r="324">
                                       <a:s>NoCervixProcedure</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="326">
                                       <a:s>performed</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="327">
                                    <a:s>toInterval ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="331"> ends on or before </a:s>
                              <a:s r="328">
                                 <a:s>end of </a:s>
                                 <a:s r="329">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
                  <a:s>
    union </a:s>
                  <a:s r="344">
                     <a:s>( </a:s>
                     <a:s r="344">
                        <a:s>
                           <a:s r="333">
                              <a:s r="336">
                                 <a:s r="336">
                                    <a:s>[Condition: </a:s>
                                    <a:s>
                                       <a:s>&quot;Congenital or Acquired Absence of Cervix&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> NoCervixDiagnosis</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
        </a:s>
                        <a:s r="343">
                           <a:s>where </a:s>
                           <a:s r="343">
                              <a:s r="339">
                                 <a:s r="338">
                                    <a:s>NoCervixDiagnosis</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="339">
                                    <a:s>prevalenceInterval ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="343"> starts on or before </a:s>
                              <a:s r="340">
                                 <a:s>end of </a:s>
                                 <a:s r="341">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="355" locator="57:3-62:5" xsi:type="Union">
            <operand localId="345" xsi:type="As">
               <operand localId="332" locator="57:3-59:3" xsi:type="Query">
                  <source localId="318" locator="57:5-57:106" alias="NoCervixProcedure">
                     <expression localId="323" locator="57:5-57:88" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                        <operand localId="321" locator="57:7-57:61" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="320" locator="57:21-57:58" name="Hysterectomy with No Residual Cervix" preserve="true" xsi:type="ValueSetRef"/>
                        </operand>
                     </expression>
                  </source>
                  <where localId="331" locator="58:7-58:100" xsi:type="SameOrBefore">
                     <operand localId="330" locator="58:56-58:59" xsi:type="End">
                        <operand localId="327" locator="58:13-58:54" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                           <operand localId="326" locator="58:13-58:39" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="325" path="performed" scope="NoCervixProcedure" xsi:type="Property"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="328" locator="58:74-58:100" xsi:type="End">
                        <operand localId="329" locator="58:81-58:100" name="Measurement Period" xsi:type="ParameterRef"/>
                     </operand>
                  </where>
               </operand>
               <asTypeSpecifier localId="346" xsi:type="ListTypeSpecifier">
                  <elementType localId="347" xsi:type="ChoiceTypeSpecifier">
                     <choice localId="348" name="fhir:Procedure" xsi:type="NamedTypeSpecifier"/>
                     <choice localId="349" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
                  </elementType>
               </asTypeSpecifier>
            </operand>
            <operand localId="350" xsi:type="As">
               <operand localId="344" locator="60:11-62:5" xsi:type="Query">
                  <source localId="333" locator="60:13-60:85" alias="NoCervixDiagnosis">
                     <expression localId="336" locator="60:13-60:67" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                        <codes localId="335" locator="60:25-60:66" name="Congenital or Acquired Absence of Cervix" preserve="true" xsi:type="ValueSetRef"/>
                     </expression>
                  </source>
                  <where localId="343" locator="61:9-61:102" xsi:type="SameOrBefore">
                     <operand localId="342" locator="61:56-61:61" xsi:type="Start">
                        <operand localId="339" locator="61:15-61:54" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                           <operand localId="338" locator="61:15-61:31" name="NoCervixDiagnosis" xsi:type="AliasRef"/>
                        </operand>
                     </operand>
                     <operand localId="340" locator="61:76-61:102" xsi:type="End">
                        <operand localId="341" locator="61:83-61:102" name="Measurement Period" xsi:type="ParameterRef"/>
                     </operand>
                  </where>
               </operand>
               <asTypeSpecifier localId="351" xsi:type="ListTypeSpecifier">
                  <elementType localId="352" xsi:type="ChoiceTypeSpecifier">
                     <choice localId="353" name="fhir:Procedure" xsi:type="NamedTypeSpecifier"/>
                     <choice localId="354" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
                  </elementType>
               </asTypeSpecifier>
            </operand>
         </expression>
      </def>
      <def localId="310" locator="47:1-50:69" name="Denominator Exclusions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="310">
               <a:s>define &quot;Denominator Exclusions&quot;:
  </a:s>
               <a:s r="311">
                  <a:s r="312">
                     <a:s r="314">
                        <a:s r="313">
                           <a:s>Hospice</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="314">
                           <a:s>&quot;Has Hospice Services&quot;</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="315">
                        <a:s>exists </a:s>
                        <a:s r="356">
                           <a:s>&quot;Absence of Cervix&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    or </a:s>
                  <a:s r="358">
                     <a:s r="357">
                        <a:s>PalliativeCare</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="358">
                        <a:s>&quot;Has Palliative Care in the Measurement Period&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="311" locator="48:3-50:69" xsi:type="Or">
            <operand localId="312" locator="48:3-49:33" xsi:type="Or">
               <operand localId="314" locator="48:3-48:32" name="Has Hospice Services" libraryName="Hospice" xsi:type="ExpressionRef"/>
               <operand localId="315" locator="49:8-49:33" xsi:type="Exists">
                  <operand localId="356" locator="49:15-49:33" name="Absence of Cervix" xsi:type="ExpressionRef"/>
               </operand>
            </operand>
            <operand localId="358" locator="50:8-50:69" name="Has Palliative Care in the Measurement Period" libraryName="PalliativeCare" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="364" locator="64:1-67:44" name="Cervical Cytology Within 3 Years" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="364">
               <a:s>define &quot;Cervical Cytology Within 3 Years&quot;:
  </a:s>
               <a:s r="436">
                  <a:s>
                     <a:s r="365">
                        <a:s r="370">
                           <a:s>( </a:s>
                           <a:s r="370">
                              <a:s r="368">
                                 <a:s>( </a:s>
                                 <a:s r="368">
                                    <a:s>[Observation: </a:s>
                                    <a:s>
                                       <a:s>&quot;Pap Test&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="370">
                                 <a:s>isLaboratoryTestPerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> CervicalCytology</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="371">
                     <a:s>where </a:s>
                     <a:s r="371">
                        <a:s r="430">
                           <a:s r="375">
                              <a:s r="374">
                                 <a:s r="372">
                                    <a:s>CervicalCytology</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="374">
                                    <a:s>effective</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="375">
                                 <a:s>latest ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="430"> during day of </a:s>
                           <a:s r="428">
                              <a:s>Interval[</a:s>
                              <a:s r="422">
                                 <a:s r="423">
                                    <a:s>start of </a:s>
                                    <a:s r="424">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> - </a:s>
                                 <a:s r="425">
                                    <a:s>2 years</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="426">
                                 <a:s>end of </a:s>
                                 <a:s r="427">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="435">
                           <a:s r="433">
                              <a:s r="431">
                                 <a:s>CervicalCytology</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="433">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s> is not null</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="436" locator="65:3-67:44" xsi:type="Query">
            <source localId="365" locator="65:3-65:82" alias="CervicalCytology">
               <expression localId="370" locator="65:3-65:65" name="isLaboratoryTestPerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="368" locator="65:5-65:33" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="367" locator="65:21-65:30" name="Pap Test" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="371" locator="66:5-67:44" xsi:type="And">
               <operand localId="430" locator="66:11-66:140" precision="Day" xsi:type="In">
                  <operand localId="375" locator="66:11-66:47" name="latest" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="385" xsi:type="Case">
                        <caseItem localId="386">
                           <when localId="387" isType="t:DateTime" xsi:type="Is">
                              <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                              </operand>
                           </when>
                           <then localId="377" xsi:type="As">
                              <operand localId="376" asType="t:DateTime" xsi:type="As">
                                 <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                                 </operand>
                              </operand>
                              <asTypeSpecifier localId="378" xsi:type="ChoiceTypeSpecifier">
                                 <choice localId="379" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="380" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="381" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="382" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice localId="383" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="384" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <caseItem localId="388">
                           <when localId="389" xsi:type="Is">
                              <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                              </operand>
                              <isTypeSpecifier localId="390" xsi:type="IntervalTypeSpecifier">
                                 <pointType localId="391" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </isTypeSpecifier>
                           </when>
                           <then localId="395" xsi:type="As">
                              <operand localId="392" xsi:type="As">
                                 <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                                 </operand>
                                 <asTypeSpecifier localId="393" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="394" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </asTypeSpecifier>
                              </operand>
                              <asTypeSpecifier localId="396" xsi:type="ChoiceTypeSpecifier">
                                 <choice localId="397" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="398" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="399" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="400" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice localId="401" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="402" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <caseItem localId="403">
                           <when localId="404" isType="t:DateTime" xsi:type="Is">
                              <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                              </operand>
                           </when>
                           <then localId="406" xsi:type="As">
                              <operand localId="405" asType="t:DateTime" xsi:type="As">
                                 <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                                 </operand>
                              </operand>
                              <asTypeSpecifier localId="407" xsi:type="ChoiceTypeSpecifier">
                                 <choice localId="408" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="409" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="410" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="411" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice localId="412" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="413" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <else localId="414" xsi:type="Null"/>
                     </operand>
                  </operand>
                  <operand localId="428" locator="66:63-66:140" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="422" locator="66:72-66:110" xsi:type="Subtract">
                        <operand localId="423" locator="66:72-66:100" xsi:type="Start">
                           <operand localId="424" locator="66:81-66:100" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                        <operand localId="425" locator="66:104-66:110" value="2" unit="years" xsi:type="Quantity"/>
                     </low>
                     <high localId="426" locator="66:113-66:139" xsi:type="End">
                        <operand localId="427" locator="66:120-66:139" name="Measurement Period" xsi:type="ParameterRef"/>
                     </high>
                  </operand>
               </operand>
               <operand localId="435" locator="67:11-67:44" xsi:type="Not">
                  <operand localId="434" locator="67:11-67:44" xsi:type="IsNull">
                     <operand localId="433" locator="67:11-67:32" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="432" path="value" scope="CervicalCytology" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="440" locator="69:1-73:35" name="HPV Test Within 5 Years for Women Age 30 and Older" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="440">
               <a:s>define &quot;HPV Test Within 5 Years for Women Age 30 and Older&quot;:
  </a:s>
               <a:s r="572">
                  <a:s>
                     <a:s r="441">
                        <a:s r="446">
                           <a:s>( </a:s>
                           <a:s r="446">
                              <a:s r="444">
                                 <a:s>( </a:s>
                                 <a:s r="444">
                                    <a:s>[Observation: </a:s>
                                    <a:s>
                                       <a:s>&quot;HPV Test&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="446">
                                 <a:s>isLaboratoryTestPerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> HPVTest</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="447">
                     <a:s>where </a:s>
                     <a:s r="447">
                        <a:s r="448">
                           <a:s r="449">
                              <a:s r="506">
                                 <a:s>AgeInYearsAt(</a:s>
                                 <a:s r="450">
                                    <a:s>date from </a:s>
                                    <a:s r="454">
                                       <a:s r="453">
                                          <a:s r="451">
                                             <a:s>HPVTest</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="453">
                                             <a:s>effective</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="454">
                                          <a:s>latest()</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s r="507"> >= 30</a:s>
                           </a:s>
                           <a:s>
      and </a:s>
                           <a:s r="566">
                              <a:s r="511">
                                 <a:s r="510">
                                    <a:s r="508">
                                       <a:s>HPVTest</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="510">
                                       <a:s>effective</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="511">
                                    <a:s>latest ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="566"> during day of </a:s>
                              <a:s r="564">
                                 <a:s>Interval[</a:s>
                                 <a:s r="558">
                                    <a:s r="559">
                                       <a:s>start of </a:s>
                                       <a:s r="560">
                                          <a:s>&quot;Measurement Period&quot;</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> - </a:s>
                                    <a:s r="561">
                                       <a:s>4 years</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="562">
                                    <a:s>end of </a:s>
                                    <a:s r="563">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="571">
                           <a:s r="569">
                              <a:s r="567">
                                 <a:s>HPVTest</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="569">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s> is not null</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="572" locator="70:3-73:35" xsi:type="Query">
            <source localId="441" locator="70:3-70:73" alias="HPVTest">
               <expression localId="446" locator="70:3-70:65" name="isLaboratoryTestPerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="444" locator="70:5-70:33" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="443" locator="70:21-70:30" name="HPV Test" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="447" locator="71:5-73:35" xsi:type="And">
               <operand localId="448" locator="71:11-72:131" xsi:type="And">
                  <operand localId="449" locator="71:11-71:66" xsi:type="GreaterOrEqual">
                     <operand localId="506" locator="71:11-71:60" precision="Year" xsi:type="CalculateAgeAt">
                        <operand localId="505" path="value" xsi:type="Property">
                           <source localId="504" path="birthDate" xsi:type="Property">
                              <source localId="503" name="Patient" xsi:type="ExpressionRef"/>
                           </source>
                        </operand>
                        <operand localId="450" locator="71:24-71:59" xsi:type="DateFrom">
                           <operand localId="454" locator="71:34-71:59" name="latest" libraryName="QICoreCommon" xsi:type="FunctionRef">
                              <operand localId="464" xsi:type="Case">
                                 <caseItem localId="465">
                                    <when localId="466" isType="t:DateTime" xsi:type="Is">
                                       <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                       </operand>
                                    </when>
                                    <then localId="456" xsi:type="As">
                                       <operand localId="455" asType="t:DateTime" xsi:type="As">
                                          <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="457" xsi:type="ChoiceTypeSpecifier">
                                          <choice localId="458" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="459" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="460" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="461" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                          <choice localId="462" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="463" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                       </asTypeSpecifier>
                                    </then>
                                 </caseItem>
                                 <caseItem localId="467">
                                    <when localId="468" xsi:type="Is">
                                       <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                       </operand>
                                       <isTypeSpecifier localId="469" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="470" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </isTypeSpecifier>
                                    </when>
                                    <then localId="474" xsi:type="As">
                                       <operand localId="471" xsi:type="As">
                                          <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                          </operand>
                                          <asTypeSpecifier localId="472" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="473" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </asTypeSpecifier>
                                       </operand>
                                       <asTypeSpecifier localId="475" xsi:type="ChoiceTypeSpecifier">
                                          <choice localId="476" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="477" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="478" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="479" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                          <choice localId="480" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="481" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                       </asTypeSpecifier>
                                    </then>
                                 </caseItem>
                                 <caseItem localId="482">
                                    <when localId="483" isType="t:DateTime" xsi:type="Is">
                                       <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                       </operand>
                                    </when>
                                    <then localId="485" xsi:type="As">
                                       <operand localId="484" asType="t:DateTime" xsi:type="As">
                                          <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="486" xsi:type="ChoiceTypeSpecifier">
                                          <choice localId="487" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="488" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="489" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="490" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                          <choice localId="491" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="492" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                       </asTypeSpecifier>
                                    </then>
                                 </caseItem>
                                 <else localId="493" xsi:type="Null"/>
                              </operand>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="507" locator="71:65-71:66" valueType="t:Integer" value="30" xsi:type="Literal"/>
                  </operand>
                  <operand localId="566" locator="72:11-72:131" precision="Day" xsi:type="In">
                     <operand localId="511" locator="72:11-72:38" name="latest" libraryName="QICoreCommon" xsi:type="FunctionRef">
                        <operand localId="521" xsi:type="Case">
                           <caseItem localId="522">
                              <when localId="523" isType="t:DateTime" xsi:type="Is">
                                 <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                 </operand>
                              </when>
                              <then localId="513" xsi:type="As">
                                 <operand localId="512" asType="t:DateTime" xsi:type="As">
                                    <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                    </operand>
                                 </operand>
                                 <asTypeSpecifier localId="514" xsi:type="ChoiceTypeSpecifier">
                                    <choice localId="515" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="516" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="517" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="518" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                    <choice localId="519" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="520" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                 </asTypeSpecifier>
                              </then>
                           </caseItem>
                           <caseItem localId="524">
                              <when localId="525" xsi:type="Is">
                                 <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                 </operand>
                                 <isTypeSpecifier localId="526" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="527" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </isTypeSpecifier>
                              </when>
                              <then localId="531" xsi:type="As">
                                 <operand localId="528" xsi:type="As">
                                    <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                    </operand>
                                    <asTypeSpecifier localId="529" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="530" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </operand>
                                 <asTypeSpecifier localId="532" xsi:type="ChoiceTypeSpecifier">
                                    <choice localId="533" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="534" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="535" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="536" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                    <choice localId="537" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="538" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                 </asTypeSpecifier>
                              </then>
                           </caseItem>
                           <caseItem localId="539">
                              <when localId="540" isType="t:DateTime" xsi:type="Is">
                                 <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                 </operand>
                              </when>
                              <then localId="542" xsi:type="As">
                                 <operand localId="541" asType="t:DateTime" xsi:type="As">
                                    <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                    </operand>
                                 </operand>
                                 <asTypeSpecifier localId="543" xsi:type="ChoiceTypeSpecifier">
                                    <choice localId="544" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="545" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="546" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="547" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                    <choice localId="548" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="549" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                 </asTypeSpecifier>
                              </then>
                           </caseItem>
                           <else localId="550" xsi:type="Null"/>
                        </operand>
                     </operand>
                     <operand localId="564" locator="72:54-72:131" lowClosed="true" highClosed="true" xsi:type="Interval">
                        <low localId="558" locator="72:63-72:101" xsi:type="Subtract">
                           <operand localId="559" locator="72:63-72:91" xsi:type="Start">
                              <operand localId="560" locator="72:72-72:91" name="Measurement Period" xsi:type="ParameterRef"/>
                           </operand>
                           <operand localId="561" locator="72:95-72:101" value="4" unit="years" xsi:type="Quantity"/>
                        </low>
                        <high localId="562" locator="72:104-72:130" xsi:type="End">
                           <operand localId="563" locator="72:111-72:130" name="Measurement Period" xsi:type="ParameterRef"/>
                        </high>
                     </operand>
                  </operand>
               </operand>
               <operand localId="571" locator="73:11-73:35" xsi:type="Not">
                  <operand localId="570" locator="73:11-73:35" xsi:type="IsNull">
                     <operand localId="569" locator="73:11-73:23" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="568" path="value" scope="HPVTest" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="360" locator="52:1-54:66" name="Numerator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="360">
               <a:s>define &quot;Numerator&quot;:
  </a:s>
               <a:s r="361">
                  <a:s r="362">
                     <a:s>exists </a:s>
                     <a:s r="437">
                        <a:s>&quot;Cervical Cytology Within 3 Years&quot;</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    or </a:s>
                  <a:s r="438">
                     <a:s>exists </a:s>
                     <a:s r="573">
                        <a:s>&quot;HPV Test Within 5 Years for Women Age 30 and Older&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="361" locator="53:3-54:66" xsi:type="Or">
            <operand localId="362" locator="53:3-53:43" xsi:type="Exists">
               <operand localId="437" locator="53:10-53:43" name="Cervical Cytology Within 3 Years" xsi:type="ExpressionRef"/>
            </operand>
            <operand localId="438" locator="54:8-54:66" xsi:type="Exists">
               <operand localId="573" locator="54:15-54:66" name="HPV Test Within 5 Years for Women Age 30 and Older" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="575" locator="75:1-76:21" name="SDE Ethnicity" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="575">
               <a:s>define &quot;SDE Ethnicity&quot;:
  </a:s>
               <a:s r="577">
                  <a:s r="576">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="577">
                     <a:s>&quot;SDE Ethnicity&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="577" locator="76:3-76:21" name="SDE Ethnicity" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="579" locator="78:1-79:17" name="SDE Payer" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="579">
               <a:s>define &quot;SDE Payer&quot;:
  </a:s>
               <a:s r="581">
                  <a:s r="580">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="581">
                     <a:s>&quot;SDE Payer&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="581" locator="79:3-79:17" name="SDE Payer" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="583" locator="81:1-82:16" name="SDE Race" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="583">
               <a:s>define &quot;SDE Race&quot;:
  </a:s>
               <a:s r="585">
                  <a:s r="584">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="585">
                     <a:s>&quot;SDE Race&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="585" locator="82:3-82:16" name="SDE Race" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="587" locator="84:1-85:15" name="SDE Sex" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="587">
               <a:s>define &quot;SDE Sex&quot;:
  </a:s>
               <a:s r="589">
                  <a:s r="588">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="589">
                     <a:s>&quot;SDE Sex&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="589" locator="85:3-85:15" name="SDE Sex" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
   </statements>
</library>
" + }, + { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "localId" : "0",
      "annotation" : [ {
         "translatorVersion" : "3.10.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "signatureLevel" : "None",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "s" : {
            "r" : "587",
            "s" : [ {
               "value" : [ "","library CervicalCancerScreeningFHIR version '0.0.001'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "CervicalCancerScreeningFHIR",
         "system" : "http://ecqi.healthit.gov/ecqms",
         "version" : "0.0.001"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localId" : "1",
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "206",
            "locator" : "3:1-3:28",
            "localIdentifier" : "QICore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "206",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICore" ]
                     } ]
                  }, {
                     "value" : [ " version '4.1.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "207",
            "locator" : "5:1-5:56",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://ecqi.healthit.gov/ecqms/FHIRHelpers",
            "version" : "4.4.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "207",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.4.000'"," called ","FHIRHelpers" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "208",
            "locator" : "6:1-6:61",
            "localIdentifier" : "SDE",
            "path" : "http://ecqi.healthit.gov/ecqms/SupplementalDataElements",
            "version" : "3.5.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "208",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "SupplementalDataElements" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.5.000'"," called ","SDE" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "209",
            "locator" : "7:1-7:58",
            "localIdentifier" : "QICoreCommon",
            "path" : "http://ecqi.healthit.gov/ecqms/QICoreCommon",
            "version" : "2.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "209",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'2.1.000'"," called ","QICoreCommon" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "210",
            "locator" : "8:1-8:49",
            "localIdentifier" : "Hospice",
            "path" : "http://ecqi.healthit.gov/ecqms/Hospice",
            "version" : "6.12.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "210",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Hospice" ]
                     } ]
                  }, {
                     "value" : [ " version ","'6.12.000'"," called ","Hospice" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "211",
            "locator" : "9:1-9:63",
            "localIdentifier" : "PalliativeCare",
            "path" : "http://ecqi.healthit.gov/ecqms/PalliativeCare",
            "version" : "1.11.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "211",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "PalliativeCare" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.11.000'"," called ","PalliativeCare" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "212",
            "locator" : "10:1-10:46",
            "localIdentifier" : "Status",
            "path" : "http://ecqi.healthit.gov/ecqms/Status",
            "version" : "1.8.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "212",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Status" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.8.000'"," called ","Status" ]
                  } ]
               }
            } ]
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "223",
            "locator" : "23:1-23:49",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "223",
                  "s" : [ {
                     "value" : [ "","parameter ","\"Measurement Period\""," " ]
                  }, {
                     "r" : "224",
                     "s" : [ {
                        "value" : [ "Interval<" ]
                     }, {
                        "r" : "225",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  } ]
               }
            } ],
            "parameterTypeSpecifier" : {
               "localId" : "224",
               "locator" : "23:32-23:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "225",
                  "locator" : "23:41-23:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "213",
            "locator" : "12:1-12:132",
            "name" : "Congenital or Acquired Absence of Cervix",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "213",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Congenital or Acquired Absence of Cervix\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "214",
            "locator" : "13:1-13:116",
            "name" : "Home Healthcare Services",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "214",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Home Healthcare Services\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "215",
            "locator" : "14:1-14:100",
            "name" : "HPV Test",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "215",
                  "s" : [ {
                     "value" : [ "","valueset ","\"HPV Test\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "216",
            "locator" : "15:1-15:128",
            "name" : "Hysterectomy with No Residual Cervix",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "216",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Hysterectomy with No Residual Cervix\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "217",
            "locator" : "16:1-16:104",
            "name" : "Office Visit",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "217",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Office Visit\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "218",
            "locator" : "17:1-17:109",
            "name" : "Virtual Encounter",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "218",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Virtual Encounter\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "219",
            "locator" : "18:1-18:100",
            "name" : "Pap Test",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "219",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Pap Test\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "220",
            "locator" : "19:1-19:152",
            "name" : "Preventive Care Services Established Office Visit, 18 and Up",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "220",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Preventive Care Services Established Office Visit, 18 and Up\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "221",
            "locator" : "20:1-20:148",
            "name" : "Preventive Care Services Initial Office Visit, 18 and Up",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "221",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Preventive Care Services Initial Office Visit, 18 and Up\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "222",
            "locator" : "21:1-21:108",
            "name" : "Telephone Visits",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "222",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Telephone Visits\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         } ]
      },
      "contexts" : {
         "def" : [ {
            "localId" : "229",
            "locator" : "25:1-25:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "localId" : "227",
            "locator" : "25:1-25:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "localId" : "228",
               "type" : "SingletonFrom",
               "signature" : [ ],
               "operand" : {
                  "localId" : "226",
                  "locator" : "25:1-25:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient",
                  "type" : "Retrieve",
                  "include" : [ ],
                  "codeFilter" : [ ],
                  "dateFilter" : [ ],
                  "otherFilter" : [ ]
               }
            }
         }, {
            "localId" : "254",
            "locator" : "34:1-42:82",
            "name" : "Qualifying Encounters",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "254",
                  "s" : [ {
                     "value" : [ "","define ","\"Qualifying Encounters\"",":\n  " ]
                  }, {
                     "r" : "304",
                     "s" : [ {
                        "s" : [ {
                           "r" : "255",
                           "s" : [ {
                              "r" : "287",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "287",
                                 "s" : [ {
                                    "r" : "286",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "286",
                                       "s" : [ {
                                          "r" : "280",
                                          "s" : [ {
                                             "r" : "275",
                                             "s" : [ {
                                                "r" : "269",
                                                "s" : [ {
                                                   "r" : "264",
                                                   "s" : [ {
                                                      "r" : "258",
                                                      "s" : [ {
                                                         "value" : [ "[","\"Encounter\"",": " ]
                                                      }, {
                                                         "s" : [ {
                                                            "value" : [ "\"Office Visit\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "]" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n      union " ]
                                                   }, {
                                                      "r" : "262",
                                                      "s" : [ {
                                                         "value" : [ "[","Encounter",": " ]
                                                      }, {
                                                         "s" : [ {
                                                            "value" : [ "\"Preventive Care Services Established Office Visit, 18 and Up\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "]" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n      union " ]
                                                }, {
                                                   "r" : "267",
                                                   "s" : [ {
                                                      "value" : [ "[","Encounter",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Preventive Care Services Initial Office Visit, 18 and Up\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n      union " ]
                                             }, {
                                                "r" : "272",
                                                "s" : [ {
                                                   "value" : [ "[","Encounter",": " ]
                                                }, {
                                                   "s" : [ {
                                                      "value" : [ "\"Home Healthcare Services\"" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "\n      union " ]
                                          }, {
                                             "r" : "278",
                                             "s" : [ {
                                                "value" : [ "[","Encounter",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Telephone Visits\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n      union " ]
                                       }, {
                                          "r" : "283",
                                          "s" : [ {
                                             "value" : [ "[","Encounter",": " ]
                                          }, {
                                             "s" : [ {
                                                "value" : [ "\"Virtual Encounter\"" ]
                                             } ]
                                          }, {
                                             "value" : [ "]" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n  )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "287",
                                    "s" : [ {
                                       "value" : [ "isEncounterPerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","ValidEncounters" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "302",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "302",
                           "s" : [ {
                              "r" : "291",
                              "s" : [ {
                                 "r" : "290",
                                 "s" : [ {
                                    "r" : "288",
                                    "s" : [ {
                                       "value" : [ "ValidEncounters" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "290",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "291",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "302",
                              "value" : [ " ","during day of"," " ]
                           }, {
                              "r" : "301",
                              "s" : [ {
                                 "value" : [ "\"Measurement Period\"" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "304",
               "locator" : "35:3-42:82",
               "type" : "Query",
               "source" : [ {
                  "localId" : "255",
                  "locator" : "35:3-41:46",
                  "alias" : "ValidEncounters",
                  "expression" : {
                     "localId" : "287",
                     "locator" : "35:3-41:30",
                     "name" : "isEncounterPerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "286",
                        "locator" : "35:5-41:3",
                        "type" : "Union",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "275",
                           "locator" : "35:7-38:51",
                           "type" : "Union",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "264",
                              "locator" : "35:7-36:87",
                              "type" : "Union",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "258",
                                 "locator" : "35:7-35:35",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "257",
                                    "locator" : "35:21-35:34",
                                    "name" : "Office Visit",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              }, {
                                 "localId" : "262",
                                 "locator" : "36:13-36:87",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "261",
                                    "locator" : "36:25-36:86",
                                    "name" : "Preventive Care Services Established Office Visit, 18 and Up",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              } ]
                           }, {
                              "localId" : "274",
                              "type" : "Union",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "267",
                                 "locator" : "37:13-37:83",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "266",
                                    "locator" : "37:25-37:82",
                                    "name" : "Preventive Care Services Initial Office Visit, 18 and Up",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              }, {
                                 "localId" : "272",
                                 "locator" : "38:13-38:51",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "271",
                                    "locator" : "38:25-38:50",
                                    "name" : "Home Healthcare Services",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              } ]
                           } ]
                        }, {
                           "localId" : "285",
                           "type" : "Union",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "278",
                              "locator" : "39:13-39:43",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                              "codeProperty" : "type",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "277",
                                 "locator" : "39:25-39:42",
                                 "name" : "Telephone Visits",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }, {
                              "localId" : "283",
                              "locator" : "40:13-40:44",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                              "codeProperty" : "type",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "282",
                                 "locator" : "40:25-40:43",
                                 "name" : "Virtual Encounter",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           } ]
                        } ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "302",
                  "locator" : "42:5-42:82",
                  "precision" : "Day",
                  "type" : "IncludedIn",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "291",
                     "locator" : "42:11-42:47",
                     "name" : "toInterval",
                     "libraryName" : "QICoreCommon",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "292",
                        "type" : "As",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "290",
                           "locator" : "42:11-42:32",
                           "name" : "ToInterval",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "289",
                              "path" : "period",
                              "scope" : "ValidEncounters",
                              "type" : "Property"
                           } ]
                        },
                        "asTypeSpecifier" : {
                           "localId" : "293",
                           "type" : "ChoiceTypeSpecifier",
                           "type" : [ ],
                           "choice" : [ {
                              "localId" : "294",
                              "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                              "type" : "NamedTypeSpecifier"
                           }, {
                              "localId" : "295",
                              "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                              "type" : "NamedTypeSpecifier"
                           }, {
                              "localId" : "296",
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "localId" : "297",
                                 "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }, {
                              "localId" : "298",
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "localId" : "299",
                                 "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }, {
                              "localId" : "300",
                              "name" : "{http://hl7.org/fhir}Timing",
                              "type" : "NamedTypeSpecifier"
                           } ]
                        }
                     } ]
                  }, {
                     "localId" : "301",
                     "locator" : "42:63-42:82",
                     "name" : "Measurement Period",
                     "type" : "ParameterRef"
                  } ]
               }
            }
         }, {
            "localId" : "231",
            "locator" : "27:1-32:38",
            "name" : "Initial Population",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "231",
                  "s" : [ {
                     "value" : [ "","define ","\"Initial Population\"",":\n  " ]
                  }, {
                     "r" : "232",
                     "s" : [ {
                        "r" : "233",
                        "s" : [ {
                           "r" : "246",
                           "s" : [ {
                              "r" : "242",
                              "s" : [ {
                                 "value" : [ "AgeInYearsAt","(" ]
                              }, {
                                 "r" : "234",
                                 "s" : [ {
                                    "value" : [ "date from \n    " ]
                                 }, {
                                    "r" : "235",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "236",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n  )" ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "245",
                              "s" : [ {
                                 "r" : "243",
                                 "value" : [ "Interval[","24",", ","64","]" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    and " ]
                        }, {
                           "r" : "247",
                           "s" : [ {
                              "r" : "250",
                              "s" : [ {
                                 "r" : "248",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "250",
                                 "s" : [ {
                                    "value" : [ "gender" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "251",
                              "s" : [ {
                                 "value" : [ "'female'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    and " ]
                     }, {
                        "r" : "252",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "305",
                           "s" : [ {
                              "value" : [ "\"Qualifying Encounters\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "232",
               "locator" : "28:3-32:38",
               "type" : "And",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "233",
                  "locator" : "28:3-31:33",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "246",
                     "locator" : "28:3-30:23",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "242",
                        "locator" : "28:3-30:3",
                        "precision" : "Year",
                        "type" : "CalculateAgeAt",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "241",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "240",
                              "path" : "birthDate",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "239",
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           }
                        }, {
                           "localId" : "234",
                           "locator" : "28:16-29:31",
                           "type" : "DateFrom",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "235",
                              "locator" : "29:5-29:31",
                              "type" : "End",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "236",
                                 "locator" : "29:12-29:31",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "localId" : "245",
                        "locator" : "30:8-30:23",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "243",
                           "locator" : "30:17-30:18",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "24",
                           "type" : "Literal"
                        },
                        "high" : {
                           "localId" : "244",
                           "locator" : "30:21-30:22",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "64",
                           "type" : "Literal"
                        }
                     } ]
                  }, {
                     "localId" : "247",
                     "locator" : "31:9-31:33",
                     "type" : "Equal",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "250",
                        "locator" : "31:9-31:22",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "249",
                           "path" : "gender",
                           "type" : "Property",
                           "source" : {
                              "localId" : "248",
                              "locator" : "31:9-31:15",
                              "name" : "Patient",
                              "type" : "ExpressionRef"
                           }
                        }
                     }, {
                        "localId" : "251",
                        "locator" : "31:26-31:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "female",
                        "type" : "Literal"
                     } ]
                  } ]
               }, {
                  "localId" : "252",
                  "locator" : "32:9-32:38",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "305",
                     "locator" : "32:16-32:38",
                     "name" : "Qualifying Encounters",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "307",
            "locator" : "44:1-45:22",
            "name" : "Denominator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "307",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator\"",":\n  " ]
                  }, {
                     "r" : "308",
                     "s" : [ {
                        "value" : [ "\"Initial Population\"" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "308",
               "locator" : "45:3-45:22",
               "name" : "Initial Population",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "317",
            "locator" : "56:1-62:5",
            "name" : "Absence of Cervix",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "317",
                  "s" : [ {
                     "value" : [ "","define ","\"Absence of Cervix\"",":\n  " ]
                  }, {
                     "r" : "355",
                     "s" : [ {
                        "r" : "332",
                        "s" : [ {
                           "value" : [ "( " ]
                        }, {
                           "r" : "332",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "318",
                                 "s" : [ {
                                    "r" : "323",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "323",
                                       "s" : [ {
                                          "r" : "321",
                                          "s" : [ {
                                             "value" : [ "( " ]
                                          }, {
                                             "r" : "321",
                                             "s" : [ {
                                                "value" : [ "[","Procedure",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Hysterectomy with No Residual Cervix\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          }, {
                                             "value" : [ " )" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "323",
                                          "s" : [ {
                                             "value" : [ "isProcedurePerformed"," ( )" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ " ","NoCervixProcedure" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "331",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "331",
                                 "s" : [ {
                                    "r" : "327",
                                    "s" : [ {
                                       "r" : "326",
                                       "s" : [ {
                                          "r" : "324",
                                          "s" : [ {
                                             "value" : [ "NoCervixProcedure" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "326",
                                          "s" : [ {
                                             "value" : [ "performed" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "327",
                                       "s" : [ {
                                          "value" : [ "toInterval"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "331",
                                    "value" : [ " ","ends on or before"," " ]
                                 }, {
                                    "r" : "328",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "329",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     }, {
                        "value" : [ "\n    union " ]
                     }, {
                        "r" : "344",
                        "s" : [ {
                           "value" : [ "( " ]
                        }, {
                           "r" : "344",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "333",
                                 "s" : [ {
                                    "r" : "336",
                                    "s" : [ {
                                       "r" : "336",
                                       "s" : [ {
                                          "value" : [ "[","Condition",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Congenital or Acquired Absence of Cervix\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","NoCervixDiagnosis" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n        " ]
                           }, {
                              "r" : "343",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "343",
                                 "s" : [ {
                                    "r" : "339",
                                    "s" : [ {
                                       "r" : "338",
                                       "s" : [ {
                                          "value" : [ "NoCervixDiagnosis" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "339",
                                       "s" : [ {
                                          "value" : [ "prevalenceInterval"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "343",
                                    "value" : [ " ","starts on or before"," " ]
                                 }, {
                                    "r" : "340",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "341",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "355",
               "locator" : "57:3-62:5",
               "type" : "Union",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "345",
                  "type" : "As",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "332",
                     "locator" : "57:3-59:3",
                     "type" : "Query",
                     "source" : [ {
                        "localId" : "318",
                        "locator" : "57:5-57:106",
                        "alias" : "NoCervixProcedure",
                        "expression" : {
                           "localId" : "323",
                           "locator" : "57:5-57:88",
                           "name" : "isProcedurePerformed",
                           "libraryName" : "Status",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "321",
                              "locator" : "57:7-57:61",
                              "dataType" : "{http://hl7.org/fhir}Procedure",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "320",
                                 "locator" : "57:21-57:58",
                                 "name" : "Hysterectomy with No Residual Cervix",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           } ]
                        }
                     } ],
                     "let" : [ ],
                     "relationship" : [ ],
                     "where" : {
                        "localId" : "331",
                        "locator" : "58:7-58:100",
                        "type" : "SameOrBefore",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "330",
                           "locator" : "58:56-58:59",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "327",
                              "locator" : "58:13-58:54",
                              "name" : "toInterval",
                              "libraryName" : "QICoreCommon",
                              "type" : "FunctionRef",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "326",
                                 "locator" : "58:13-58:39",
                                 "name" : "ToValue",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "325",
                                    "path" : "performed",
                                    "scope" : "NoCervixProcedure",
                                    "type" : "Property"
                                 } ]
                              } ]
                           }
                        }, {
                           "localId" : "328",
                           "locator" : "58:74-58:100",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "329",
                              "locator" : "58:81-58:100",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        } ]
                     }
                  },
                  "asTypeSpecifier" : {
                     "localId" : "346",
                     "type" : "ListTypeSpecifier",
                     "elementType" : {
                        "localId" : "347",
                        "type" : "ChoiceTypeSpecifier",
                        "type" : [ ],
                        "choice" : [ {
                           "localId" : "348",
                           "name" : "{http://hl7.org/fhir}Procedure",
                           "type" : "NamedTypeSpecifier"
                        }, {
                           "localId" : "349",
                           "name" : "{http://hl7.org/fhir}Condition",
                           "type" : "NamedTypeSpecifier"
                        } ]
                     }
                  }
               }, {
                  "localId" : "350",
                  "type" : "As",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "344",
                     "locator" : "60:11-62:5",
                     "type" : "Query",
                     "source" : [ {
                        "localId" : "333",
                        "locator" : "60:13-60:85",
                        "alias" : "NoCervixDiagnosis",
                        "expression" : {
                           "localId" : "336",
                           "locator" : "60:13-60:67",
                           "dataType" : "{http://hl7.org/fhir}Condition",
                           "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                           "codeProperty" : "code",
                           "codeComparator" : "in",
                           "type" : "Retrieve",
                           "codes" : {
                              "localId" : "335",
                              "locator" : "60:25-60:66",
                              "name" : "Congenital or Acquired Absence of Cervix",
                              "preserve" : true,
                              "type" : "ValueSetRef"
                           },
                           "include" : [ ],
                           "codeFilter" : [ ],
                           "dateFilter" : [ ],
                           "otherFilter" : [ ]
                        }
                     } ],
                     "let" : [ ],
                     "relationship" : [ ],
                     "where" : {
                        "localId" : "343",
                        "locator" : "61:9-61:102",
                        "type" : "SameOrBefore",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "342",
                           "locator" : "61:56-61:61",
                           "type" : "Start",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "339",
                              "locator" : "61:15-61:54",
                              "name" : "prevalenceInterval",
                              "libraryName" : "QICoreCommon",
                              "type" : "FunctionRef",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "338",
                                 "locator" : "61:15-61:31",
                                 "name" : "NoCervixDiagnosis",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }, {
                           "localId" : "340",
                           "locator" : "61:76-61:102",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "341",
                              "locator" : "61:83-61:102",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        } ]
                     }
                  },
                  "asTypeSpecifier" : {
                     "localId" : "351",
                     "type" : "ListTypeSpecifier",
                     "elementType" : {
                        "localId" : "352",
                        "type" : "ChoiceTypeSpecifier",
                        "type" : [ ],
                        "choice" : [ {
                           "localId" : "353",
                           "name" : "{http://hl7.org/fhir}Procedure",
                           "type" : "NamedTypeSpecifier"
                        }, {
                           "localId" : "354",
                           "name" : "{http://hl7.org/fhir}Condition",
                           "type" : "NamedTypeSpecifier"
                        } ]
                     }
                  }
               } ]
            }
         }, {
            "localId" : "310",
            "locator" : "47:1-50:69",
            "name" : "Denominator Exclusions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "310",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator Exclusions\"",":\n  " ]
                  }, {
                     "r" : "311",
                     "s" : [ {
                        "r" : "312",
                        "s" : [ {
                           "r" : "314",
                           "s" : [ {
                              "r" : "313",
                              "s" : [ {
                                 "value" : [ "Hospice" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "314",
                              "s" : [ {
                                 "value" : [ "\"Has Hospice Services\"" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "315",
                           "s" : [ {
                              "value" : [ "exists " ]
                           }, {
                              "r" : "356",
                              "s" : [ {
                                 "value" : [ "\"Absence of Cervix\"" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    or " ]
                     }, {
                        "r" : "358",
                        "s" : [ {
                           "r" : "357",
                           "s" : [ {
                              "value" : [ "PalliativeCare" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "358",
                           "s" : [ {
                              "value" : [ "\"Has Palliative Care in the Measurement Period\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "311",
               "locator" : "48:3-50:69",
               "type" : "Or",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "312",
                  "locator" : "48:3-49:33",
                  "type" : "Or",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "314",
                     "locator" : "48:3-48:32",
                     "name" : "Has Hospice Services",
                     "libraryName" : "Hospice",
                     "type" : "ExpressionRef"
                  }, {
                     "localId" : "315",
                     "locator" : "49:8-49:33",
                     "type" : "Exists",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "356",
                        "locator" : "49:15-49:33",
                        "name" : "Absence of Cervix",
                        "type" : "ExpressionRef"
                     }
                  } ]
               }, {
                  "localId" : "358",
                  "locator" : "50:8-50:69",
                  "name" : "Has Palliative Care in the Measurement Period",
                  "libraryName" : "PalliativeCare",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "364",
            "locator" : "64:1-67:44",
            "name" : "Cervical Cytology Within 3 Years",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "364",
                  "s" : [ {
                     "value" : [ "","define ","\"Cervical Cytology Within 3 Years\"",":\n  " ]
                  }, {
                     "r" : "436",
                     "s" : [ {
                        "s" : [ {
                           "r" : "365",
                           "s" : [ {
                              "r" : "370",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "370",
                                 "s" : [ {
                                    "r" : "368",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "368",
                                       "s" : [ {
                                          "value" : [ "[","Observation",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Pap Test\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "370",
                                    "s" : [ {
                                       "value" : [ "isLaboratoryTestPerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","CervicalCytology" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "371",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "371",
                           "s" : [ {
                              "r" : "430",
                              "s" : [ {
                                 "r" : "375",
                                 "s" : [ {
                                    "r" : "374",
                                    "s" : [ {
                                       "r" : "372",
                                       "s" : [ {
                                          "value" : [ "CervicalCytology" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "374",
                                       "s" : [ {
                                          "value" : [ "effective" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "375",
                                    "s" : [ {
                                       "value" : [ "latest"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "430",
                                 "value" : [ " ","during day of"," " ]
                              }, {
                                 "r" : "428",
                                 "s" : [ {
                                    "value" : [ "Interval[" ]
                                 }, {
                                    "r" : "422",
                                    "s" : [ {
                                       "r" : "423",
                                       "s" : [ {
                                          "value" : [ "start of " ]
                                       }, {
                                          "r" : "424",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " - " ]
                                    }, {
                                       "r" : "425",
                                       "s" : [ {
                                          "value" : [ "2 ","years" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "426",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "427",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "435",
                              "s" : [ {
                                 "r" : "433",
                                 "s" : [ {
                                    "r" : "431",
                                    "s" : [ {
                                       "value" : [ "CervicalCytology" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "433",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " is not null" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "436",
               "locator" : "65:3-67:44",
               "type" : "Query",
               "source" : [ {
                  "localId" : "365",
                  "locator" : "65:3-65:82",
                  "alias" : "CervicalCytology",
                  "expression" : {
                     "localId" : "370",
                     "locator" : "65:3-65:65",
                     "name" : "isLaboratoryTestPerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "368",
                        "locator" : "65:5-65:33",
                        "dataType" : "{http://hl7.org/fhir}Observation",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "367",
                           "locator" : "65:21-65:30",
                           "name" : "Pap Test",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "371",
                  "locator" : "66:5-67:44",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "430",
                     "locator" : "66:11-66:140",
                     "precision" : "Day",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "375",
                        "locator" : "66:11-66:47",
                        "name" : "latest",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "385",
                           "type" : "Case",
                           "caseItem" : [ {
                              "localId" : "386",
                              "when" : {
                                 "localId" : "387",
                                 "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "Is",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "374",
                                    "locator" : "66:11-66:36",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "373",
                                       "path" : "effective",
                                       "scope" : "CervicalCytology",
                                       "type" : "Property"
                                    } ]
                                 }
                              },
                              "then" : {
                                 "localId" : "377",
                                 "type" : "As",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "376",
                                    "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "374",
                                       "locator" : "66:11-66:36",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "373",
                                          "path" : "effective",
                                          "scope" : "CervicalCytology",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "localId" : "378",
                                    "type" : "ChoiceTypeSpecifier",
                                    "type" : [ ],
                                    "choice" : [ {
                                       "localId" : "379",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "380",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "381",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "382",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "localId" : "383",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "384",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           }, {
                              "localId" : "388",
                              "when" : {
                                 "localId" : "389",
                                 "type" : "Is",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "374",
                                    "locator" : "66:11-66:36",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "373",
                                       "path" : "effective",
                                       "scope" : "CervicalCytology",
                                       "type" : "Property"
                                    } ]
                                 },
                                 "isTypeSpecifier" : {
                                    "localId" : "390",
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "localId" : "391",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "localId" : "395",
                                 "type" : "As",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "392",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "374",
                                       "locator" : "66:11-66:36",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "373",
                                          "path" : "effective",
                                          "scope" : "CervicalCytology",
                                          "type" : "Property"
                                       } ]
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "393",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "394",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "localId" : "396",
                                    "type" : "ChoiceTypeSpecifier",
                                    "type" : [ ],
                                    "choice" : [ {
                                       "localId" : "397",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "398",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "399",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "400",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "localId" : "401",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "402",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           }, {
                              "localId" : "403",
                              "when" : {
                                 "localId" : "404",
                                 "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "Is",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "374",
                                    "locator" : "66:11-66:36",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "373",
                                       "path" : "effective",
                                       "scope" : "CervicalCytology",
                                       "type" : "Property"
                                    } ]
                                 }
                              },
                              "then" : {
                                 "localId" : "406",
                                 "type" : "As",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "405",
                                    "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "374",
                                       "locator" : "66:11-66:36",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "373",
                                          "path" : "effective",
                                          "scope" : "CervicalCytology",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "localId" : "407",
                                    "type" : "ChoiceTypeSpecifier",
                                    "type" : [ ],
                                    "choice" : [ {
                                       "localId" : "408",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "409",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "410",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "411",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "localId" : "412",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "413",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           } ],
                           "else" : {
                              "localId" : "414",
                              "type" : "Null"
                           }
                        } ]
                     }, {
                        "localId" : "428",
                        "locator" : "66:63-66:140",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "422",
                           "locator" : "66:72-66:110",
                           "type" : "Subtract",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "423",
                              "locator" : "66:72-66:100",
                              "type" : "Start",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "424",
                                 "locator" : "66:81-66:100",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }, {
                              "localId" : "425",
                              "locator" : "66:104-66:110",
                              "value" : 2,
                              "unit" : "years",
                              "type" : "Quantity"
                           } ]
                        },
                        "high" : {
                           "localId" : "426",
                           "locator" : "66:113-66:139",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "427",
                              "locator" : "66:120-66:139",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        }
                     } ]
                  }, {
                     "localId" : "435",
                     "locator" : "67:11-67:44",
                     "type" : "Not",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "434",
                        "locator" : "67:11-67:44",
                        "type" : "IsNull",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "433",
                           "locator" : "67:11-67:32",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "432",
                              "path" : "value",
                              "scope" : "CervicalCytology",
                              "type" : "Property"
                           } ]
                        }
                     }
                  } ]
               }
            }
         }, {
            "localId" : "440",
            "locator" : "69:1-73:35",
            "name" : "HPV Test Within 5 Years for Women Age 30 and Older",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "440",
                  "s" : [ {
                     "value" : [ "","define ","\"HPV Test Within 5 Years for Women Age 30 and Older\"",":\n  " ]
                  }, {
                     "r" : "572",
                     "s" : [ {
                        "s" : [ {
                           "r" : "441",
                           "s" : [ {
                              "r" : "446",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "446",
                                 "s" : [ {
                                    "r" : "444",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "444",
                                       "s" : [ {
                                          "value" : [ "[","Observation",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"HPV Test\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "446",
                                    "s" : [ {
                                       "value" : [ "isLaboratoryTestPerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","HPVTest" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "447",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "447",
                           "s" : [ {
                              "r" : "448",
                              "s" : [ {
                                 "r" : "449",
                                 "s" : [ {
                                    "r" : "506",
                                    "s" : [ {
                                       "value" : [ "AgeInYearsAt","(" ]
                                    }, {
                                       "r" : "450",
                                       "s" : [ {
                                          "value" : [ "date from " ]
                                       }, {
                                          "r" : "454",
                                          "s" : [ {
                                             "r" : "453",
                                             "s" : [ {
                                                "r" : "451",
                                                "s" : [ {
                                                   "value" : [ "HPVTest" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "453",
                                                "s" : [ {
                                                   "value" : [ "effective" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "454",
                                             "s" : [ {
                                                "value" : [ "latest","()" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "r" : "507",
                                    "value" : [ " ",">="," ","30" ]
                                 } ]
                              }, {
                                 "value" : [ "\n      and " ]
                              }, {
                                 "r" : "566",
                                 "s" : [ {
                                    "r" : "511",
                                    "s" : [ {
                                       "r" : "510",
                                       "s" : [ {
                                          "r" : "508",
                                          "s" : [ {
                                             "value" : [ "HPVTest" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "510",
                                          "s" : [ {
                                             "value" : [ "effective" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "511",
                                       "s" : [ {
                                          "value" : [ "latest"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "566",
                                    "value" : [ " ","during day of"," " ]
                                 }, {
                                    "r" : "564",
                                    "s" : [ {
                                       "value" : [ "Interval[" ]
                                    }, {
                                       "r" : "558",
                                       "s" : [ {
                                          "r" : "559",
                                          "s" : [ {
                                             "value" : [ "start of " ]
                                          }, {
                                             "r" : "560",
                                             "s" : [ {
                                                "value" : [ "\"Measurement Period\"" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " - " ]
                                       }, {
                                          "r" : "561",
                                          "s" : [ {
                                             "value" : [ "4 ","years" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "562",
                                       "s" : [ {
                                          "value" : [ "end of " ]
                                       }, {
                                          "r" : "563",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "571",
                              "s" : [ {
                                 "r" : "569",
                                 "s" : [ {
                                    "r" : "567",
                                    "s" : [ {
                                       "value" : [ "HPVTest" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "569",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " is not null" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "572",
               "locator" : "70:3-73:35",
               "type" : "Query",
               "source" : [ {
                  "localId" : "441",
                  "locator" : "70:3-70:73",
                  "alias" : "HPVTest",
                  "expression" : {
                     "localId" : "446",
                     "locator" : "70:3-70:65",
                     "name" : "isLaboratoryTestPerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "444",
                        "locator" : "70:5-70:33",
                        "dataType" : "{http://hl7.org/fhir}Observation",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "443",
                           "locator" : "70:21-70:30",
                           "name" : "HPV Test",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "447",
                  "locator" : "71:5-73:35",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "448",
                     "locator" : "71:11-72:131",
                     "type" : "And",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "449",
                        "locator" : "71:11-71:66",
                        "type" : "GreaterOrEqual",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "506",
                           "locator" : "71:11-71:60",
                           "precision" : "Year",
                           "type" : "CalculateAgeAt",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "505",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "504",
                                 "path" : "birthDate",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "503",
                                    "name" : "Patient",
                                    "type" : "ExpressionRef"
                                 }
                              }
                           }, {
                              "localId" : "450",
                              "locator" : "71:24-71:59",
                              "type" : "DateFrom",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "454",
                                 "locator" : "71:34-71:59",
                                 "name" : "latest",
                                 "libraryName" : "QICoreCommon",
                                 "type" : "FunctionRef",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "464",
                                    "type" : "Case",
                                    "caseItem" : [ {
                                       "localId" : "465",
                                       "when" : {
                                          "localId" : "466",
                                          "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "Is",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "453",
                                             "locator" : "71:34-71:50",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "signature" : [ ],
                                             "operand" : [ {
                                                "localId" : "452",
                                                "path" : "effective",
                                                "scope" : "HPVTest",
                                                "type" : "Property"
                                             } ]
                                          }
                                       },
                                       "then" : {
                                          "localId" : "456",
                                          "type" : "As",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "455",
                                             "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "As",
                                             "signature" : [ ],
                                             "operand" : {
                                                "localId" : "453",
                                                "locator" : "71:34-71:50",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "signature" : [ ],
                                                "operand" : [ {
                                                   "localId" : "452",
                                                   "path" : "effective",
                                                   "scope" : "HPVTest",
                                                   "type" : "Property"
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "457",
                                             "type" : "ChoiceTypeSpecifier",
                                             "type" : [ ],
                                             "choice" : [ {
                                                "localId" : "458",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "459",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "460",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "461",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }, {
                                                "localId" : "462",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "463",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }
                                       }
                                    }, {
                                       "localId" : "467",
                                       "when" : {
                                          "localId" : "468",
                                          "type" : "Is",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "453",
                                             "locator" : "71:34-71:50",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "signature" : [ ],
                                             "operand" : [ {
                                                "localId" : "452",
                                                "path" : "effective",
                                                "scope" : "HPVTest",
                                                "type" : "Property"
                                             } ]
                                          },
                                          "isTypeSpecifier" : {
                                             "localId" : "469",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "470",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       },
                                       "then" : {
                                          "localId" : "474",
                                          "type" : "As",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "471",
                                             "type" : "As",
                                             "signature" : [ ],
                                             "operand" : {
                                                "localId" : "453",
                                                "locator" : "71:34-71:50",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "signature" : [ ],
                                                "operand" : [ {
                                                   "localId" : "452",
                                                   "path" : "effective",
                                                   "scope" : "HPVTest",
                                                   "type" : "Property"
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "472",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "473",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "475",
                                             "type" : "ChoiceTypeSpecifier",
                                             "type" : [ ],
                                             "choice" : [ {
                                                "localId" : "476",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "477",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "478",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "479",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }, {
                                                "localId" : "480",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "481",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }
                                       }
                                    }, {
                                       "localId" : "482",
                                       "when" : {
                                          "localId" : "483",
                                          "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "Is",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "453",
                                             "locator" : "71:34-71:50",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "signature" : [ ],
                                             "operand" : [ {
                                                "localId" : "452",
                                                "path" : "effective",
                                                "scope" : "HPVTest",
                                                "type" : "Property"
                                             } ]
                                          }
                                       },
                                       "then" : {
                                          "localId" : "485",
                                          "type" : "As",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "484",
                                             "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "As",
                                             "signature" : [ ],
                                             "operand" : {
                                                "localId" : "453",
                                                "locator" : "71:34-71:50",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "signature" : [ ],
                                                "operand" : [ {
                                                   "localId" : "452",
                                                   "path" : "effective",
                                                   "scope" : "HPVTest",
                                                   "type" : "Property"
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "486",
                                             "type" : "ChoiceTypeSpecifier",
                                             "type" : [ ],
                                             "choice" : [ {
                                                "localId" : "487",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "488",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "489",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "490",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }, {
                                                "localId" : "491",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "492",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }
                                       }
                                    } ],
                                    "else" : {
                                       "localId" : "493",
                                       "type" : "Null"
                                    }
                                 } ]
                              }
                           } ]
                        }, {
                           "localId" : "507",
                           "locator" : "71:65-71:66",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "30",
                           "type" : "Literal"
                        } ]
                     }, {
                        "localId" : "566",
                        "locator" : "72:11-72:131",
                        "precision" : "Day",
                        "type" : "In",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "511",
                           "locator" : "72:11-72:38",
                           "name" : "latest",
                           "libraryName" : "QICoreCommon",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "521",
                              "type" : "Case",
                              "caseItem" : [ {
                                 "localId" : "522",
                                 "when" : {
                                    "localId" : "523",
                                    "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "Is",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "510",
                                       "locator" : "72:11-72:27",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "509",
                                          "path" : "effective",
                                          "scope" : "HPVTest",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "then" : {
                                    "localId" : "513",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "512",
                                       "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "As",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "510",
                                          "locator" : "72:11-72:27",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "509",
                                             "path" : "effective",
                                             "scope" : "HPVTest",
                                             "type" : "Property"
                                          } ]
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "514",
                                       "type" : "ChoiceTypeSpecifier",
                                       "type" : [ ],
                                       "choice" : [ {
                                          "localId" : "515",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "516",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "517",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "518",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }, {
                                          "localId" : "519",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "520",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }
                                 }
                              }, {
                                 "localId" : "524",
                                 "when" : {
                                    "localId" : "525",
                                    "type" : "Is",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "510",
                                       "locator" : "72:11-72:27",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "509",
                                          "path" : "effective",
                                          "scope" : "HPVTest",
                                          "type" : "Property"
                                       } ]
                                    },
                                    "isTypeSpecifier" : {
                                       "localId" : "526",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "527",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "then" : {
                                    "localId" : "531",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "528",
                                       "type" : "As",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "510",
                                          "locator" : "72:11-72:27",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "509",
                                             "path" : "effective",
                                             "scope" : "HPVTest",
                                             "type" : "Property"
                                          } ]
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "529",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "530",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "532",
                                       "type" : "ChoiceTypeSpecifier",
                                       "type" : [ ],
                                       "choice" : [ {
                                          "localId" : "533",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "534",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "535",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "536",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }, {
                                          "localId" : "537",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "538",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }
                                 }
                              }, {
                                 "localId" : "539",
                                 "when" : {
                                    "localId" : "540",
                                    "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "Is",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "510",
                                       "locator" : "72:11-72:27",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "509",
                                          "path" : "effective",
                                          "scope" : "HPVTest",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "then" : {
                                    "localId" : "542",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "541",
                                       "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "As",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "510",
                                          "locator" : "72:11-72:27",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "509",
                                             "path" : "effective",
                                             "scope" : "HPVTest",
                                             "type" : "Property"
                                          } ]
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "543",
                                       "type" : "ChoiceTypeSpecifier",
                                       "type" : [ ],
                                       "choice" : [ {
                                          "localId" : "544",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "545",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "546",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "547",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }, {
                                          "localId" : "548",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "549",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }
                                 }
                              } ],
                              "else" : {
                                 "localId" : "550",
                                 "type" : "Null"
                              }
                           } ]
                        }, {
                           "localId" : "564",
                           "locator" : "72:54-72:131",
                           "lowClosed" : true,
                           "highClosed" : true,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "558",
                              "locator" : "72:63-72:101",
                              "type" : "Subtract",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "559",
                                 "locator" : "72:63-72:91",
                                 "type" : "Start",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "560",
                                    "locator" : "72:72-72:91",
                                    "name" : "Measurement Period",
                                    "type" : "ParameterRef"
                                 }
                              }, {
                                 "localId" : "561",
                                 "locator" : "72:95-72:101",
                                 "value" : 4,
                                 "unit" : "years",
                                 "type" : "Quantity"
                              } ]
                           },
                           "high" : {
                              "localId" : "562",
                              "locator" : "72:104-72:130",
                              "type" : "End",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "563",
                                 "locator" : "72:111-72:130",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     } ]
                  }, {
                     "localId" : "571",
                     "locator" : "73:11-73:35",
                     "type" : "Not",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "570",
                        "locator" : "73:11-73:35",
                        "type" : "IsNull",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "569",
                           "locator" : "73:11-73:23",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "568",
                              "path" : "value",
                              "scope" : "HPVTest",
                              "type" : "Property"
                           } ]
                        }
                     }
                  } ]
               }
            }
         }, {
            "localId" : "360",
            "locator" : "52:1-54:66",
            "name" : "Numerator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "360",
                  "s" : [ {
                     "value" : [ "","define ","\"Numerator\"",":\n  " ]
                  }, {
                     "r" : "361",
                     "s" : [ {
                        "r" : "362",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "437",
                           "s" : [ {
                              "value" : [ "\"Cervical Cytology Within 3 Years\"" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    or " ]
                     }, {
                        "r" : "438",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "573",
                           "s" : [ {
                              "value" : [ "\"HPV Test Within 5 Years for Women Age 30 and Older\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "361",
               "locator" : "53:3-54:66",
               "type" : "Or",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "362",
                  "locator" : "53:3-53:43",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "437",
                     "locator" : "53:10-53:43",
                     "name" : "Cervical Cytology Within 3 Years",
                     "type" : "ExpressionRef"
                  }
               }, {
                  "localId" : "438",
                  "locator" : "54:8-54:66",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "573",
                     "locator" : "54:15-54:66",
                     "name" : "HPV Test Within 5 Years for Women Age 30 and Older",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "575",
            "locator" : "75:1-76:21",
            "name" : "SDE Ethnicity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "575",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Ethnicity\"",":\n  " ]
                  }, {
                     "r" : "577",
                     "s" : [ {
                        "r" : "576",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "577",
                        "s" : [ {
                           "value" : [ "\"SDE Ethnicity\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "577",
               "locator" : "76:3-76:21",
               "name" : "SDE Ethnicity",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "579",
            "locator" : "78:1-79:17",
            "name" : "SDE Payer",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "579",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Payer\"",":\n  " ]
                  }, {
                     "r" : "581",
                     "s" : [ {
                        "r" : "580",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "581",
                        "s" : [ {
                           "value" : [ "\"SDE Payer\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "581",
               "locator" : "79:3-79:17",
               "name" : "SDE Payer",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "583",
            "locator" : "81:1-82:16",
            "name" : "SDE Race",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "583",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Race\"",":\n  " ]
                  }, {
                     "r" : "585",
                     "s" : [ {
                        "r" : "584",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "585",
                        "s" : [ {
                           "value" : [ "\"SDE Race\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "585",
               "locator" : "82:3-82:16",
               "name" : "SDE Race",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "587",
            "locator" : "84:1-85:15",
            "name" : "SDE Sex",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "587",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Sex\"",":\n  " ]
                  }, {
                     "r" : "589",
                     "s" : [ {
                        "r" : "588",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "589",
                        "s" : [ {
                           "value" : [ "\"SDE Sex\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "589",
               "locator" : "85:3-85:15",
               "name" : "SDE Sex",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         } ]
      }
   }
}" + } + ] + }, + "request": { + "method": "PUT", + "url": "Library/CervicalCancerScreeningFHIR" + } + }, + { + "fullUrl": "https://madie.cms.gov/Measure/BreastCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Measure", + "id": "BreastCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/publishable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/executable-measure-cqfm" + ] + }, + "contained": [ + { + "resourceType": "Library", + "id": "effective-data-requirements", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428361000124107", + "display": "Discharge to home for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428371000124100", + "display": "Discharge to healthcare facility for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/observation-category", + "code": "survey", + "display": "survey" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "373066001", + "display": "Yes (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "24028007", + "display": "Right (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "7771000", + "display": "Left (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "98181-1", + "display": "Medical equipment used" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "160734000", + "display": "Lives in a nursing home (finding)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "October 1 Two Years Prior to the Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"October 1 Two Years Prior to the Measurement Period\":\n DateTime((year from start of \"Measurement Period\" - 2), 10, 1, 0, 0, 0, 0, 0)" + }, + { + "url": "displaySequence", + "valueInteger": 0 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Numerator" + }, + { + "url": "statement", + "valueString": "define \"Numerator\":\n exists ( ( ( [Observation: \"Mammography\"] ).isDiagnosticStudyPerformed ( ) ) Mammogram\n where Mammogram.effective.toInterval ( ) ends during day of Interval[\"October 1 Two Years Prior to the Measurement Period\", end of \"Measurement Period\"]\n )" + }, + { + "url": "displaySequence", + "valueInteger": 1 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdultOutpatientEncounters" + }, + { + "url": "name", + "valueString": "Qualifying Encounters" + }, + { + "url": "statement", + "valueString": "define \"Qualifying Encounters\":\n ( ( [Encounter: \"Office Visit\"]\n union [Encounter: \"Annual Wellness Visit\"]\n union [Encounter: \"Preventive Care Services Established Office Visit, 18 and Up\"]\n union [Encounter: \"Preventive Care Services Initial Office Visit, 18 and Up\"]\n union [Encounter: \"Home Healthcare Services\"]\n union [Encounter: \"Virtual Encounter\"]\n union [Encounter: \"Telephone Visits\"] ).isEncounterPerformed() ) ValidEncounter\n where ValidEncounter.period.toInterval() during day of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 2 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Initial Population" + }, + { + "url": "statement", + "valueString": "define \"Initial Population\":\n AgeInYearsAt(date from \n end of \"Measurement Period\"\n ) in Interval[52, 74]\n and Patient.gender = 'female'\n and exists AdultOutpatientEncounters.\"Qualifying Encounters\"" + }, + { + "url": "displaySequence", + "valueInteger": 3 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator" + }, + { + "url": "statement", + "valueString": "define \"Denominator\":\n \"Initial Population\"" + }, + { + "url": "displaySequence", + "valueInteger": 4 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Hospice" + }, + { + "url": "name", + "valueString": "Has Hospice Services" + }, + { + "url": "statement", + "valueString": "define \"Has Hospice Services\":\n exists ((([Encounter: \"Encounter Inpatient\"]).isEncounterPerformed()) InpatientEncounter\n where (InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to home for hospice care (procedure)\"\n or InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to healthcare facility for hospice care (procedure)\"\n )\n and InpatientEncounter.period.toInterval() ends during day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Hospice Encounter\"]).isEncounterPerformed()) HospiceEncounter\n where HospiceEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Observation: \"Hospice care [Minimum Data Set]\"]).isAssessmentPerformed()) HospiceAssessment\n where HospiceAssessment.value ~ \"Yes (qualifier value)\"\n and HospiceAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([ServiceRequest: \"Hospice Care Ambulatory\"]).isInterventionOrder()) HospiceOrder\n where HospiceOrder.authoredOn.toInterval() during day of \"Measurement Period\"\n // and HospiceOrder.doNotPerform is not true\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-447\n )\n or exists ((([Procedure: \"Hospice Care Ambulatory\"]).isInterventionPerformed()) HospicePerformed\n where HospicePerformed.performed.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists (([Condition: \"Hospice Diagnosis\"]) HospiceCareDiagnosis\n where HospiceCareDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 5 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Right Mastectomy Diagnosis" + }, + { + "url": "statement", + "valueString": "define \"Right Mastectomy Diagnosis\":\n ( [Condition: \"Status Post Right Mastectomy\"] RightMastectomyProcedure\n union ( [Condition: \"Unilateral Mastectomy, Unspecified Laterality\"] UnilateralMastectomyDiagnosis\n where exists ( UnilateralMastectomyDiagnosis.bodySite S\n where S ~ \"Right (qualifier value)\"\n )\n ) ) RightMastectomy\n where RightMastectomy.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 6 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Right Mastectomy Procedure" + }, + { + "url": "statement", + "valueString": "define \"Right Mastectomy Procedure\":\n ( ( [Procedure: \"Unilateral Mastectomy Right\"] ).isProcedurePerformed ( ) ) UnilateralMastectomyRightPerformed\n where UnilateralMastectomyRightPerformed.performed.toInterval ( ) ends on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 7 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Left Mastectomy Diagnosis" + }, + { + "url": "statement", + "valueString": "define \"Left Mastectomy Diagnosis\":\n ( [Condition: \"Status Post Left Mastectomy\"]\n union ( [Condition: \"Unilateral Mastectomy, Unspecified Laterality\"] UnilateralMastectomyDiagnosis\n where exists ( UnilateralMastectomyDiagnosis.bodySite S\n where S ~ \"Left (qualifier value)\"\n )\n ) ) LeftMastectomy\n where LeftMastectomy.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 8 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Left Mastectomy Procedure" + }, + { + "url": "statement", + "valueString": "define \"Left Mastectomy Procedure\":\n ( ( [Procedure: \"Unilateral Mastectomy Left\"] ).isProcedurePerformed ( ) ) UnilateralMastectomyLeftPerformed\n where UnilateralMastectomyLeftPerformed.performed.toInterval ( ) ends on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 9 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Bilateral Mastectomy Diagnosis" + }, + { + "url": "statement", + "valueString": "define \"Bilateral Mastectomy Diagnosis\":\n [Condition: \"History of bilateral mastectomy\"] BilateralMastectomyHistory\n where BilateralMastectomyHistory.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 10 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Bilateral Mastectomy Procedure" + }, + { + "url": "statement", + "valueString": "define \"Bilateral Mastectomy Procedure\":\n ( ( [Procedure: \"Bilateral Mastectomy\"] ).isProcedurePerformed ( ) ) BilateralMastectomyPerformed\n where BilateralMastectomyPerformed.performed.toInterval ( ) ends on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 11 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Has Criteria Indicating Frailty" + }, + { + "url": "statement", + "valueString": "define \"Has Criteria Indicating Frailty\":\n exists ( (([DeviceRequest: \"Frailty Device\"]).isDeviceOrder()) FrailtyDeviceOrder\n where FrailtyDeviceOrder.doNotPerform() is not true\n and FrailtyDeviceOrder.authoredOn.toInterval() during day of \"Measurement Period\"\n )\n or exists ( (([Observation: \"Medical equipment used\"]).isAssessmentPerformed()) EquipmentUsed\n where EquipmentUsed.value as Concept in \"Frailty Device\" \n and EquipmentUsed.effective.toInterval() ends during day of \"Measurement Period\"\n )\n or exists ( ([Condition: \"Frailty Diagnosis\"]) FrailtyDiagnosis\n where FrailtyDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )\n or exists ( (([Encounter: \"Frailty Encounter\"]).isEncounterPerformed()) FrailtyEncounter\n where FrailtyEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ( (([Observation: \"Frailty Symptom\"]).isSymptom()) FrailtySymptom\n where FrailtySymptom.effective.toInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 12 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Has Advanced Illness in Year Before or During Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Advanced Illness in Year Before or During Measurement Period\":\nexists ([Condition: \"Advanced Illness\"] AdvancedIllnessDiagnosis\nwhere AdvancedIllnessDiagnosis.prevalenceInterval() starts during day of Interval[start of \"Measurement Period\" - 1 year, end of \"Measurement Period\"])" + }, + { + "url": "displaySequence", + "valueInteger": 13 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Has Dementia Medications in Year Before or During Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Dementia Medications in Year Before or During Measurement Period\":\n exists (( ([MedicationRequest: medication in \"Dementia Medications\"]).isMedicationActive()) DementiaMedication\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-449\n where DementiaMedication.medicationRequestPeriod() overlaps day of Interval[start of \"Measurement Period\" - 1 year, \n end of \"Measurement Period\"]\n // and DementiaMedication.doNotPerform is not true\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-447\n )" + }, + { + "url": "displaySequence", + "valueInteger": 14 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Is Age 66 or Older with Advanced Illness and Frailty" + }, + { + "url": "statement", + "valueString": "define \"Is Age 66 or Older with Advanced Illness and Frailty\":\n AgeInYearsAt(date from end of \"Measurement Period\")>= 66\n and \"Has Criteria Indicating Frailty\"\n and ( \"Has Advanced Illness in Year Before or During Measurement Period\"\n or \"Has Dementia Medications in Year Before or During Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 15 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Is Age 66 or Older Living Long Term in a Nursing Home" + }, + { + "url": "statement", + "valueString": "define \"Is Age 66 or Older Living Long Term in a Nursing Home\":\n AgeInYearsAt(date from \n end of \"Measurement Period\"\n )>= 66\n and ( ( Last( (([Observation: \"Housing status\"]).isAssessmentPerformed()) HousingStatus \n where HousingStatus.effective.toInterval() ends on or before \n day of end of \"Measurement Period\"\n sort by \n end of effective.toInterval() asc\n )) LastHousingStatus\n where LastHousingStatus.value ~ \"Lives in a nursing home (finding)\"\n ) is not null" + }, + { + "url": "displaySequence", + "valueInteger": 16 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "PalliativeCare" + }, + { + "url": "name", + "valueString": "Has Palliative Care in the Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Palliative Care in the Measurement Period\":\n exists ((([Observation: \"Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)\"]).isAssessmentPerformed()) PalliativeAssessment\n where PalliativeAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ([Condition: \"Palliative Care Diagnosis\"] PalliativeDiagnosis\n where PalliativeDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Palliative Care Encounter\"]).isEncounterPerformed()) PalliativeEncounter\n where PalliativeEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Procedure: \"Palliative Care Intervention\"]).isInterventionPerformed()) PalliativeIntervention\n where PalliativeIntervention.performed.toInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 17 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator Exclusions" + }, + { + "url": "statement", + "valueString": "define \"Denominator Exclusions\":\n Hospice.\"Has Hospice Services\"\n or ( ( exists ( \"Right Mastectomy Diagnosis\" )\n or exists ( \"Right Mastectomy Procedure\" )\n )\n and ( exists ( \"Left Mastectomy Diagnosis\" )\n or exists ( \"Left Mastectomy Procedure\" )\n )\n )\n or exists \"Bilateral Mastectomy Diagnosis\"\n or exists \"Bilateral Mastectomy Procedure\"\n or AIFrailLTCF.\"Is Age 66 or Older with Advanced Illness and Frailty\"\n or AIFrailLTCF.\"Is Age 66 or Older Living Long Term in a Nursing Home\"\n or PalliativeCare.\"Has Palliative Care in the Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 18 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isDiagnosticStudyPerformed" + }, + { + "url": "statement", + "valueString": "//Diagnostic Study, Performed\ndefine fluent function isDiagnosticStudyPerformed(Obs List):\n Obs O\n where O.status in {'final', 'amended', 'corrected' }" + }, + { + "url": "displaySequence", + "valueInteger": 19 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isEncounterPerformed" + }, + { + "url": "statement", + "valueString": "//Encounter, Performed\n//General usage unless required otherwise by measure intent (e.g., follow-up encounters)\ndefine fluent function isEncounterPerformed(Enc List):\n Enc E\n where E.status in {'finished', 'arrived', 'triaged', 'in-progress', 'onleave'}" + }, + { + "url": "displaySequence", + "valueInteger": 20 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "toInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval\n@comment: Normalizes a choice type of DateTime, Quanitty, Interval, or Interval types\nto an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible\nrepresentations for timing-valued elements in QICore, allowing this function to be used across any resource.\nThe input can be provided as a DateTime, Quantity, Interval or Interval.\nThe intent of this function is to provide a clear and concise mechanism to treat single\nelements that have multiple possible representations as intervals so that logic doesn't have to account\nfor the variability. More complex calculations (such as medication request period or dispense period\ncalculation) need specific guidance and consideration. That guidance may make use of this function, but\nthe focus of this function is on single element calculations where the semantics are unambiguous.\nIf the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.\nIf the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,\nand the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.\nIf the input is a DateTime Interval, the result is the input.\nIf the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result\nis a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending\nimmediately before one year later than the date the patient turned the age given as the end of the quantity interval.\nIf the input is a Timing, an error will be thrown indicating that Timing calculations are not implemented. Any other input will reslt in a null DateTime Interval\n*/\ndefine fluent function toInterval(choice Choice, Interval, Timing>):\n case\n\t when choice is DateTime then\n \tInterval[choice as DateTime, choice as DateTime]\n\t\twhen choice is Interval then\n \t\tchoice as Interval\n\t\twhen choice is Quantity then\n\t\t Interval[Patient.birthDate + (choice as Quantity),\n\t\t\t Patient.birthDate + (choice as Quantity) + 1 year)\n\t\twhen choice is Interval then\n\t\t Interval[Patient.birthDate + (choice.low as Quantity),\n\t\t\t Patient.birthDate + (choice.high as Quantity) + 1 year)\n\t\twhen choice is Timing then\n Message(null, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a Timing value is not supported') as Interval\n\t\telse\n\t\t\tnull as Interval\n\tend" + }, + { + "url": "displaySequence", + "valueInteger": 21 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isAssessmentPerformed" + }, + { + "url": "statement", + "valueString": "//This library contains functions that are based on QDM 5.6 to QICore 4.1.1 March 2023 (https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns---QICore-v4.1.1). The functions may appear similar to some QICoreCommon functions but different in that they have constraints that are relevant for measures authored by NCQA.\n\n//Assessment, Performed\ndefine fluent function isAssessmentPerformed(Obs List):\n Obs O\n where O.status in { 'final', 'amended', 'corrected' }\n and exists ( O.category ObservationCategory\n where ( ObservationCategory ) ~ \"survey\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 22 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "FHIRHelpers" + }, + { + "url": "name", + "valueString": "ToConcept" + }, + { + "url": "statement", + "valueString": "/*\n@description: Converts the given FHIR [CodeableConcept](https://hl7.org/fhir/datatypes.html#CodeableConcept) value to a CQL Concept.\n*/\ndefine function ToConcept(concept FHIR.CodeableConcept):\n if concept is null then\n null\n else\n System.Concept {\n codes: concept.coding C return ToCode(C),\n display: concept.text.value\n }" + }, + { + "url": "displaySequence", + "valueInteger": 23 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionOrder" + }, + { + "url": "statement", + "valueString": "//Intervention, Order: active and completed only \ndefine fluent function isInterventionOrder(ServiceRequest List):\n ServiceRequest S\n where S.status in { 'active', 'completed' }\n and S.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 24 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionPerformed" + }, + { + "url": "statement", + "valueString": "//Intervention, Performed\ndefine fluent function isInterventionPerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 25 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "prevalenceInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Returns an interval representing the normalized prevalence period of a given Condition.\n@comment: Uses the ToInterval and ToAbatementInterval functions to determine the widest potential interval from\nonset to abatement as specified in the given Condition. If the condition is active, or has an abatement date the resulting \ninterval will have a closed ending boundary. Otherwise, the resulting interval will have an open ending boundary.\n*/\ndefine fluent function prevalenceInterval(condition Condition):\nif condition.clinicalStatus ~ \"active\"\n or condition.clinicalStatus ~ \"recurrence\"\n or condition.clinicalStatus ~ \"relapse\" then\n Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()]\nelse\n (end of condition.abatementInterval()) abatementDate\n return if abatementDate is null then\n Interval[start of condition.onset.toInterval(), abatementDate)\n else\n Interval[start of condition.onset.toInterval(), abatementDate]" + }, + { + "url": "displaySequence", + "valueInteger": 26 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isProcedurePerformed" + }, + { + "url": "statement", + "valueString": "//Procedure, Performed\ndefine fluent function isProcedurePerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 27 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isDeviceOrder" + }, + { + "url": "statement", + "valueString": "//Device, Order - Personal Use Devices: active and completed only\ndefine fluent function isDeviceOrder(DeviceRequest List):\n DeviceRequest D\n where D.status in { 'active', 'completed' }\n and D.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 28 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "doNotPerform" + }, + { + "url": "statement", + "valueString": "/*\n@description: Returns true if the given DeviceRequest is a negation (i.e. do not perform this order)\n*/\ndefine fluent function doNotPerform(deviceRequest DeviceRequest):\n singleton from (\n deviceRequest.modifierExtension E\n where E.url = 'http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-doNotPerform'\n return E.value as Boolean\n )" + }, + { + "url": "displaySequence", + "valueInteger": 29 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isSymptom" + }, + { + "url": "statement", + "valueString": "//Symptom\ndefine fluent function isSymptom(Obs List):\n Obs O\n where O.status in { 'preliminary', 'final', 'amended', 'corrected' }" + }, + { + "url": "displaySequence", + "valueInteger": 30 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isMedicationActive" + }, + { + "url": "statement", + "valueString": "//Medication, Active\ndefine fluent function isMedicationActive(MedicationRequest List):\n MedicationRequest M\n where M.status = 'active'\n and M.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 31 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CumulativeMedicationDuration" + }, + { + "url": "name", + "valueString": "medicationRequestPeriod" + }, + { + "url": "statement", + "valueString": "define fluent function medicationRequestPeriod(Request \"MedicationRequest\"):\n Request R\n let\n dosage: singleton from R.dosageInstruction,\n doseAndRate: singleton from dosage.doseAndRate,\n timing: dosage.timing,\n frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency),\n period: Quantity(timing.repeat.period, timing.repeat.periodUnit),\n doseRange: doseAndRate.dose,\n doseQuantity: doseAndRate.dose,\n dose: Coalesce(end of doseRange, doseQuantity),\n dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0),\n boundsPeriod: timing.repeat.bounds as Interval,\n daysSupply: (convert R.dispenseRequest.expectedSupplyDuration to days).value,\n quantity: R.dispenseRequest.quantity,\n refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed, 0),\n startDate:\n Coalesce(\n date from start of boundsPeriod,\n date from R.authoredOn,\n date from start of R.dispenseRequest.validityPeriod\n ),\n totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills)\n return\n if startDate is not null and totalDaysSupplied is not null then\n Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ]\n else if startDate is not null and boundsPeriod.\"high\" is not null then\n Interval[startDate, date from end of boundsPeriod]\n else\n null" + }, + { + "url": "displaySequence", + "valueInteger": 32 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CumulativeMedicationDuration" + }, + { + "url": "name", + "valueString": "Quantity" + }, + { + "url": "statement", + "valueString": "/**********************************************************************/\n/* Functions in this region are copied from opioid-mme-r4 */\n/**********************************************************************/\n\ndefine function Quantity(value Decimal, unit String):\n if value is not null then\n System.Quantity { value: value, unit: unit }\n else\n null" + }, + { + "url": "displaySequence", + "valueInteger": 33 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CumulativeMedicationDuration" + }, + { + "url": "name", + "valueString": "ToDaily" + }, + { + "url": "statement", + "valueString": "/*\n Goal is to get to number of days\n Two broad approaches to the calculation:\n 1) Based on supply and frequency, calculate the number of expected days the medication will cover/has covered\n 2) Based on relevant period, determine a covered interval and calculate the length of that interval in days\nThis topic covers several use cases and illustrates how to calculate Cumulative\nMedication Duration for each type of medication resource using the supply and\nfrequency approach.\n*/\n\n/*\n For the first approach, we need to get from frequency to a frequency/day\n So we define ToDaily\n*/\n\n/*\n Calculates daily frequency given frequency within a period\n*/\ndefine function ToDaily(frequency System.Integer, period System.Quantity):\n case period.unit\n when 'h' then frequency * (24.0 / period.value)\n when 'min' then frequency * (24.0 / period.value) * 60\n when 's' then frequency * (24.0 / period.value) * 60 * 60\n when 'd' then frequency * (24.0 / period.value) / 24\n when 'wk' then frequency * (24.0 / period.value) / (24 * 7)\n when 'mo' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */\n when 'a' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */\n when 'hour' then frequency * (24.0 / period.value)\n when 'minute' then frequency * (24.0 / period.value) * 60\n when 'second' then frequency * (24.0 / period.value) * 60 * 60\n when 'day' then frequency * (24.0 / period.value) / 24\n when 'week' then frequency * (24.0 / period.value) / (24 * 7)\n when 'month' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */\n when 'year' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */\n when 'hours' then frequency * (24.0 / period.value)\n when 'minutes' then frequency * (24.0 / period.value) * 60\n when 'seconds' then frequency * (24.0 / period.value) * 60 * 60\n when 'days' then frequency * (24.0 / period.value) / 24\n when 'weeks' then frequency * (24.0 / period.value) / (24 * 7)\n when 'months' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */\n when 'years' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */\n else Message(null, true, 'CMDLogic.ToDaily.UnknownUnit', ErrorLevel, 'Unknown unit ' & period.unit)\n end" + }, + { + "url": "displaySequence", + "valueInteger": 34 + } + ] + } + ], + "name": "EffectiveDataRequirements", + "status": "active", + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "module-definition" + } + ] + }, + "relatedArtifact": [ + { + "type": "depends-on", + "display": "Library Status", + "resource": "Library/Status|1.8.000" + }, + { + "type": "depends-on", + "display": "Library QICoreCommon", + "resource": "Library/QICoreCommon|2.1.000" + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "Library/FHIRHelpers|4.4.000" + }, + { + "type": "depends-on", + "display": "Library AdultOutpatientEncounters", + "resource": "Library/AdultOutpatientEncounters|4.11.000" + }, + { + "type": "depends-on", + "display": "Library Hospice", + "resource": "Library/Hospice|6.12.000" + }, + { + "type": "depends-on", + "display": "Library AIFrailLTCF", + "resource": "Library/AdvancedIllnessandFrailty|1.16.000" + }, + { + "type": "depends-on", + "display": "Library CMD", + "resource": "Library/CumulativeMedicationDuration|4.1.000" + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": "Library/PalliativeCare|1.11.000" + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, + { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": "http://terminology.hl7.org/CodeSystem/observation-category" + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, + { + "type": "depends-on", + "display": "Value set Mammography", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" + }, + { + "type": "depends-on", + "display": "Value set Office Visit", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + }, + { + "type": "depends-on", + "display": "Value set Annual Wellness Visit", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Established Office Visit, 18 and Up", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Initial Office Visit, 18 and Up", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + }, + { + "type": "depends-on", + "display": "Value set Home Healthcare Services", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + }, + { + "type": "depends-on", + "display": "Value set Virtual Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + }, + { + "type": "depends-on", + "display": "Value set Telephone Visits", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + }, + { + "type": "depends-on", + "display": "Value set Encounter Inpatient", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + }, + { + "type": "depends-on", + "display": "Value set Hospice Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + }, + { + "type": "depends-on", + "display": "Value set Hospice Care Ambulatory", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + }, + { + "type": "depends-on", + "display": "Value set Hospice Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + }, + { + "type": "depends-on", + "display": "Value set Status Post Right Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy, Unspecified Laterality", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Right", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + }, + { + "type": "depends-on", + "display": "Value set Status Post Left Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Left", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + }, + { + "type": "depends-on", + "display": "Value set History of bilateral mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" + }, + { + "type": "depends-on", + "display": "Value set Bilateral Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" + }, + { + "type": "depends-on", + "display": "Value set Frailty Device", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + }, + { + "type": "depends-on", + "display": "Value set Frailty Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1074" + }, + { + "type": "depends-on", + "display": "Value set Frailty Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1088" + }, + { + "type": "depends-on", + "display": "Value set Frailty Symptom", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1075" + }, + { + "type": "depends-on", + "display": "Value set Advanced Illness", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1082" + }, + { + "type": "depends-on", + "display": "Value set Dementia Medications", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.196.12.1510" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Intervention", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "ErrorLevel", + "use": "in", + "min": 0, + "max": "1", + "type": "string" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + } + ], + "dataRequirement": [ + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ] + }, + { + "path": "value" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "98181-1", + "display": "Medical equipment used" + } + ] + }, + { + "path": "value", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + ], + "dateFilter": [ + { + "path": "effective", + "valuePeriod": { + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expression", + "valueExpression": { + "language": "text/cql-identifier", + "expression": "Measurement Period" + } + } + ] + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1075" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ] + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ] + }, + { + "path": "value" + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ] + } + ] + }, + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1088" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code", "bodySite"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1074" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1082" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + ] + }, + { + "type": "DeviceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-devicerequest" + ], + "mustSupport": [ + "code", + "status", + "status.value", + "intent", + "intent.value", + "url", + "url.value", + "value", + "authoredOn", + "authoredOn.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + ] + }, + { + "type": "MedicationRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-medicationrequest" + ], + "mustSupport": [ + "medication", + "status", + "status.value", + "intent", + "intent.value", + "dosageInstruction", + "dispenseRequest", + "dispenseRequest.expectedSupplyDuration", + "dispenseRequest.quantity", + "dispenseRequest.numberOfRepeatsAllowed", + "dispenseRequest.numberOfRepeatsAllowed.value", + "authoredOn", + "authoredOn.value", + "dispenseRequest.validityPeriod" + ], + "codeFilter": [ + { + "path": "medication", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.196.12.1510" + } + ] + } + ] + } + ], + "extension": [ + { + "id": "effective-data-requirements", + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-effectiveDataRequirements", + "valueReference": { + "reference": "#effective-data-requirements" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } + ], + "url": "https://madie.cms.gov/Measure/BreastCancerScreeningFHIR", + "identifier": [ + { + "use": "usual", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "short-name" + } + ] + }, + "system": "https://madie.cms.gov/measure/shortName", + "value": "CMS125FHIR" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-independent" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:f766afa2-f780-45d2-b224-c1bdb733fa6f" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-specific" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:7c89bd23-97eb-446b-b63a-975b63503b1c" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "publisher" + } + ] + }, + "system": "https://madie.cms.gov/measure/cmsId", + "value": "125FHIR", + "assigner": { + "display": "CMS" + } + } + ], + "version": "0.0.001", + "name": "BreastCancerScreeningFHIR", + "title": "Breast Cancer ScreeningFHIR", + "status": "active", + "experimental": false, + "date": "2024-07-09T14:53:55+00:00", + "publisher": "National Committee for Quality Assurance", + "contact": [ + { + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "description": "Percentage of women 50-74 years of age who had a mammogram to screen for breast cancer in the 27 months prior to the end of the Measurement Period", + "purpose": "UNKNOWN", + "usage": "This measure evaluates primary screening. Do not count biopsies, breast ultrasounds, or MRIs because they are not appropriate methods for primary breast cancer screening. Please note the measure may include screenings performed outside the age range of patients referenced in the initial population. Screenings that occur prior to the measurement period are valid to meet measure criteria. This eCQM is a patient-based measure. This FHIR-based measure has been derived from the QDM-based measure: CMS125v13. Please refer to the HL7 QI-Core Implementation Guide (http://hl7.org/fhir/us/qicore/STU4.1.1/) for more information on QI-Core and mapping recommendations from QDM to QI-Core 4.1.1 (http://hl7.org/fhir/us/qicore/STU4.1.1/qdm-to-qicore.html).", + "copyright": "This Physician Performance Measure (Measure) and related data specifications are owned and were developed by the National Committee for Quality Assurance (NCQA). NCQA is not responsible for any use of the Measure. NCQA makes no representations, warranties, or endorsement about the quality of any organization or physician that uses or reports performance measures and NCQA has no liability to anyone who relies on such measures or specifications. NCQA holds a copyright in the Measure. The Measure can be reproduced and distributed, without modification, for noncommercial purposes (e.g., use by healthcare providers in connection with their practices) without obtaining approval from NCQA. Commercial use is defined as the sale, licensing, or distribution of the Measure for commercial gain, or incorporation of the Measure into a product or service that is sold, licensed or distributed for commercial gain. All commercial uses or requests for modification must be approved by NCQA and are subject to a license at the discretion of NCQA. (C) 2012-2024 National Committee for Quality Assurance. All Rights Reserved. Limited proprietary coding is contained in the Measure specifications for user convenience. Users of proprietary code sets should obtain all necessary licenses from the owners of the code sets. NCQA disclaims all liability for use or accuracy of any third-party codes contained in the specifications. CPT(R) codes, descriptions and other data are copyright 2024. American Medical Association. All rights reserved. CPT is a trademark of the American Medical Association. Fee schedules, relative value units, conversion factors and/or related components are not assigned by the AMA, are not part of CPT, and the AMA is not recommending their use. The AMA does not directly or indirectly practice medicine or dispense medical services. The AMA assumes no liability for data contained or not contained herein. Applicable FARS/DFARS restrictions apply to government use. Some measure specifications contain coding from LOINC(R) (http://loinc.org). The LOINC table, LOINC codes, LOINC panels and form file, LOINC linguistic variants file, LOINC/RSNA Radiology Playbook, and LOINC/IEEE Medical Device Code Mapping Table are copyright 2004-2024 Regenstrief Institute, Inc. and the Logical Observation Identifiers Names and Codes (LOINC) Committee, and are available at no cost under the license at http://loinc.org/terms-of-use. This material contains SNOMED Clinical Terms(R) (SNOMED CT[R]) copyright 2004-2023 International Health Terminology Standards Development Organisation. ICD-10 copyright 2024 World Health Organization. All Rights Reserved. Some measures use RxNorm, a standardized nomenclature and coding for clinical drugs and drug delivery devices, which is made publicly available courtesy of the U.S. National Library of Medicine (NLM), National Institutes of Health, Department of Health and Human Services. NLM is not responsible for the measures and does not endorse or recommend this or any other product. “HL7” is the registered trademark of Health Level Seven International.", + "effectivePeriod": { + "start": "2025-01-01", + "end": "2025-12-31" + }, + "author": [ + { + "name": "National Committee for Quality Assurance", + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "library": ["https://madie.cms.gov/Library/BreastCancerScreeningFHIR"], + "disclaimer": "The performance Measure is not a clinical guideline and does not establish a standard of medical care, and has not been tested for all potential applications. THE MEASURE AND SPECIFICATIONS ARE PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. Due to technical limitations, registered trademarks are indicated by (R) or [R] and unregistered trademarks are indicated by (TM) or [TM].", + "rationale": "Breast cancer is one of the most common types of cancers, accounting for 15 percent of all new cancer diagnoses in the U.S. (Noone et al., 2018). In 2015, over 3 million women were estimated to be living with breast cancer in the U.S. and it is estimated that 12 percent of women will be diagnosed with breast cancer at some point during their lifetime (Noone et al., 2018). While there are other factors that affect a woman's risk of developing breast cancer, advancing age is a primary risk factor. Breast cancer is most frequently diagnosed among women ages 55-64; the median age at diagnosis is 62 years (Noone et al., 2018). The chance of a woman being diagnosed with breast cancer in a given year increases with age. By age 40, the chances are 1 in 68; by age 50 it becomes 1 in 43; by age 60, it is 1 in 29 (American Cancer Society, 2017).", + "clinicalRecommendationStatement": "The U.S. Preventive Services Task Force (USPSTF) recommends biennial screening mammography for women aged 50-74 years (B recommendation) (USPSTF, 2016). The decision to start screening mammography in women prior to age 50 years should be an individual one. Women who place a higher value on the potential benefit than the potential harms may choose to begin biennial screening between the ages of 40 and 49 years (C recommendation) (USPSTF, 2016). The USPSTF concludes that the current evidence is insufficient to assess the balance of benefits and harms of screening mammography in women aged 75 years or older (I statement) (USPSTF, 2016). The USPSTF concludes that the current evidence is insufficient to assess the benefits and harms of digital breast tomosynthesis (DBT) as a primary screening method for breast cancer (I statement) (USPSTF, 2016). The USPSTF concludes that the current evidence is insufficient to assess the balance of benefits and harms of adjunctive screening for breast cancer using breast ultrasonography, magnetic resonance imaging, DBT, or other methods in women identified to have dense breasts on an otherwise negative screening mammogram (I statement) (USPSTF, 2016). The National Comprehensive Cancer Network (NCCN) and the American College of Radiology (ACR) recommend using conventional mammography or DBT for screening women at low, intermediate or high risk for breast cancer (NCCN, 2021) (ACR, 2017).", + "group": [ + { + "id": "64e646302ad653247b573ada", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-scoring", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-scoring", + "code": "proportion", + "display": "Proportion" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-populationBasis", + "valueCode": "boolean" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-type", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-type", + "code": "process", + "display": "Process" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-rateAggregation", + "valueCode": "None" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-improvementNotation", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-improvement-notation", + "code": "decrease", + "display": "increase" + } + ] + } + } + ], + "population": [ + { + "id": "FC061B94-3EB0-46E6-AD30-370E47E648AD", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "initial-population", + "display": "Initial Population" + } + ] + }, + "description": "Women 52-74 years of age by the end of the measurement period with a visit during the measurement period", + "criteria": { + "language": "text/cql-identifier", + "expression": "Initial Population" + } + }, + { + "id": "054B4403-E6CF-4F3C-B36B-12003F3BA268", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator", + "display": "Denominator" + } + ] + }, + "description": "Equals Initial Population", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator" + } + }, + { + "id": "209265B9-B25B-4809-BB65-DFD42207CB9D", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator-exclusion", + "display": "Denominator Exclusion" + } + ] + }, + "description": "Exclude patients who are in hospice care for any part of the measurement period. Women who had a bilateral mastectomy or who have a history of a bilateral mastectomy or for whom there is evidence of a right and a left unilateral mastectomy on or before the end of the measurement period. Exclude patients 66 and older by the end of the measurement period with an indication of frailty for any part of the measurement period who also meet any of the following advanced illness criteria: - Advanced illness diagnosis during the measurement period or the year prior - OR taking dementia medications during the measurement period or the year prior Exclude patients 66 and older by the end of the measurement period who are living long term in a nursing home any time on or before the end of the measurement period. Exclude patients receiving palliative care for any part of the measurement period.", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator Exclusions" + } + }, + { + "id": "B7745FD9-0697-40A0-A179-3056DD614C8F", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "numerator", + "display": "Numerator" + } + ] + }, + "description": "Women with one or more mammograms any time on or between October 1 two years prior to the measurement period and the end of the measurement period", + "criteria": { + "language": "text/cql-identifier", + "expression": "Numerator" + } + } + ] + } + ] + }, + "request": { + "method": "PUT", + "url": "Measure/BreastCancerScreeningFHIR" + } + }, + { + "fullUrl": "https://madie.cms.gov/Library/BreastCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Library", + "id": "BreastCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-library-cqfm" + ] + }, + "language": "en", + "contained": [ + { + "resourceType": "Parameters", + "id": "options", + "parameter": [ + { + "name": "translatorVersion", + "valueString": "3.10.0" + }, + { + "name": "option", + "valueString": "EnableAnnotations" + }, + { + "name": "option", + "valueString": "EnableLocators" + }, + { + "name": "option", + "valueString": "DisableListDemotion" + }, + { + "name": "option", + "valueString": "DisableListPromotion" + }, + { + "name": "format", + "valueString": "XML" + }, + { + "name": "format", + "valueString": "JSON" + }, + { + "name": "analyzeDataRequirements", + "valueBoolean": true + }, + { + "name": "collapseDataRequirements", + "valueBoolean": true + }, + { + "name": "compatibilityLevel", + "valueString": "1.5" + }, + { + "name": "enableCqlOnly", + "valueBoolean": false + }, + { + "name": "errorLevel", + "valueString": "Info" + }, + { + "name": "signatureLevel", + "valueString": "None" + }, + { + "name": "validateUnits", + "valueBoolean": true + }, + { + "name": "verifyOnly", + "valueBoolean": false + } + ] + } + ], + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender", + "code": "F", + "display": "Female" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "7771000", + "display": "Left (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "24028007", + "display": "Right (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlOptions", + "valueReference": { + "reference": "#options" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } + ], + "url": "https://madie.cms.gov/Library/BreastCancerScreeningFHIR", + "identifier": [ + { + "use": "official", + "system": "https://madie.cms.gov/login", + "value": "BreastCancerScreeningFHIR" + } + ], + "version": "0.0.001", + "name": "BreastCancerScreeningFHIR", + "title": "BreastCancerScreeningFHIR", + "status": "active", + "experimental": false, + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } + ] + }, + "date": "2024-05-16T15:11:55+00:00", + "description": "BreastCancerScreeningFHIR", + "relatedArtifact": [ + { + "type": "depends-on", + "display": "QICore model information", + "resource": "http://hl7.org/fhir/Library/QICore-ModelInfo" + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://ecqi.healthit.gov/ecqms/Library/FHIRHelpers|4.4.000" + }, + { + "type": "depends-on", + "display": "Library SDE", + "resource": "http://ecqi.healthit.gov/ecqms/Library/SupplementalDataElements|3.5.000" + }, + { + "type": "depends-on", + "display": "Library QICoreCommon", + "resource": "http://ecqi.healthit.gov/ecqms/Library/QICoreCommon|2.1.000" + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": "http://ecqi.healthit.gov/ecqms/Library/PalliativeCare|1.11.000" + }, + { + "type": "depends-on", + "display": "Code system AdministrativeGender", + "resource": "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender" + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, + { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": "http://terminology.hl7.org/CodeSystem/observation-category" + }, + { + "type": "depends-on", + "display": "Value set Status Post Left Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + }, + { + "type": "depends-on", + "display": "Value set Status Post Right Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Left", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Right", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy, Unspecified Laterality", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + }, + { + "type": "depends-on", + "display": "Value set Payer Type", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "ErrorLevel", + "use": "in", + "min": 0, + "max": "1", + "type": "string" + }, + { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Right Mastectomy Diagnosis", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Right Mastectomy Procedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Left Mastectomy Diagnosis", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Left Mastectomy Procedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Bilateral Mastectomy Diagnosis", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Bilateral Mastectomy Procedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "October 1 Two Years Prior to the Measurement Period", + "use": "out", + "min": 0, + "max": "1", + "type": "dateTime" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "SDE Ethnicity", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Payer", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "SDE Race", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Sex", + "use": "out", + "min": 0, + "max": "1", + "type": "Coding" + } + ], + "dataRequirement": [ + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ], + "mustSupport": ["ethnicity", "race"] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1088" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code", "bodySite"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1074" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1082" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ] + }, + { + "path": "value" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "98181-1", + "display": "Medical equipment used" + } + ] + }, + { + "path": "value", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + ], + "dateFilter": [ + { + "path": "effective", + "valuePeriod": { + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expression", + "valueExpression": { + "language": "text/cql-identifier", + "expression": "Measurement Period" + } + } + ] + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1075" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ] + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ] + }, + { + "path": "value" + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ] + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "DeviceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-devicerequest" + ], + "mustSupport": [ + "code", + "status", + "status.value", + "intent", + "intent.value", + "url", + "url.value", + "value", + "authoredOn", + "authoredOn.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + ] + }, + { + "type": "MedicationRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-medicationrequest" + ], + "mustSupport": [ + "medication", + "status", + "status.value", + "intent", + "intent.value", + "dosageInstruction", + "dispenseRequest", + "dispenseRequest.expectedSupplyDuration", + "dispenseRequest.quantity", + "dispenseRequest.numberOfRepeatsAllowed", + "dispenseRequest.numberOfRepeatsAllowed.value", + "authoredOn", + "authoredOn.value", + "dispenseRequest.validityPeriod" + ], + "codeFilter": [ + { + "path": "medication", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.196.12.1510" + } + ] + }, + { + "type": "Coverage", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-coverage" + ], + "mustSupport": ["type", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + ] + } + ], + "content": [ + { + "contentType": "text/cql", + "data": "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" + }, + { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1" localId="0">
   <annotation translatorVersion="3.10.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" signatureLevel="None" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:s r="491">
         <a:s>library BreastCancerScreeningFHIR version '0.0.001'</a:s>
      </a:s>
   </annotation>
   <identifier id="BreastCancerScreeningFHIR" system="http://ecqi.healthit.gov/ecqms" version="0.0.001"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localId="1" localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="206" locator="3:1-3:28" localIdentifier="QICore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="206">
               <a:s>using </a:s>
               <a:s>
                  <a:s>QICore</a:s>
               </a:s>
               <a:s> version '4.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="207" locator="5:1-5:56" localIdentifier="FHIRHelpers" path="http://ecqi.healthit.gov/ecqms/FHIRHelpers" version="4.4.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="207">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.4.000' called FHIRHelpers</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="208" locator="6:1-6:61" localIdentifier="SDE" path="http://ecqi.healthit.gov/ecqms/SupplementalDataElements" version="3.5.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="208">
               <a:s>include </a:s>
               <a:s>
                  <a:s>SupplementalDataElements</a:s>
               </a:s>
               <a:s> version '3.5.000' called SDE</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="209" locator="7:1-7:58" localIdentifier="QICoreCommon" path="http://ecqi.healthit.gov/ecqms/QICoreCommon" version="2.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="209">
               <a:s>include </a:s>
               <a:s>
                  <a:s>QICoreCommon</a:s>
               </a:s>
               <a:s> version '2.1.000' called QICoreCommon</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="210" locator="8:1-8:85" localIdentifier="AdultOutpatientEncounters" path="http://ecqi.healthit.gov/ecqms/AdultOutpatientEncounters" version="4.11.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="210">
               <a:s>include </a:s>
               <a:s>
                  <a:s>AdultOutpatientEncounters</a:s>
               </a:s>
               <a:s> version '4.11.000' called AdultOutpatientEncounters</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="211" locator="9:1-9:49" localIdentifier="Hospice" path="http://ecqi.healthit.gov/ecqms/Hospice" version="6.12.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="211">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Hospice</a:s>
               </a:s>
               <a:s> version '6.12.000' called Hospice</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="212" locator="10:1-10:46" localIdentifier="Status" path="http://ecqi.healthit.gov/ecqms/Status" version="1.8.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="212">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Status</a:s>
               </a:s>
               <a:s> version '1.8.000' called Status</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="213" locator="11:1-11:63" localIdentifier="PalliativeCare" path="http://ecqi.healthit.gov/ecqms/PalliativeCare" version="1.11.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="213">
               <a:s>include </a:s>
               <a:s>
                  <a:s>PalliativeCare</a:s>
               </a:s>
               <a:s> version '1.11.000' called PalliativeCare</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="214" locator="12:1-12:71" localIdentifier="AIFrailLTCF" path="http://ecqi.healthit.gov/ecqms/AdvancedIllnessandFrailty" version="1.16.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="214">
               <a:s>include </a:s>
               <a:s>
                  <a:s>AdvancedIllnessandFrailty</a:s>
               </a:s>
               <a:s> version '1.16.000' called AIFrailLTCF</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <parameters>
      <def localId="232" locator="31:1-31:49" name="Measurement Period" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="232">
               <a:s>parameter &quot;Measurement Period&quot; </a:s>
               <a:s r="233">
                  <a:s>Interval&lt;</a:s>
                  <a:s r="234">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
            </a:s>
         </annotation>
         <parameterTypeSpecifier localId="233" locator="31:32-31:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="234" locator="31:41-31:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <codeSystems>
      <def localId="215" locator="14:1-14:98" name="AdministrativeGender" id="http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="215">
               <a:s>codesystem &quot;AdministrativeGender&quot;: 'http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="216" locator="15:1-15:47" name="SNOMEDCT" id="http://snomed.info/sct" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="216">
               <a:s>codesystem &quot;SNOMEDCT&quot;: 'http://snomed.info/sct'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="217" locator="16:1-16:38" name="LOINC" id="http://loinc.org" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="217">
               <a:s>codesystem &quot;LOINC&quot;: 'http://loinc.org'</a:s>
            </a:s>
         </annotation>
      </def>
   </codeSystems>
   <valueSets>
      <def localId="218" locator="18:1-18:112" name="Bilateral Mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="218">
               <a:s>valueset &quot;Bilateral Mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="219" locator="19:1-19:123" name="History of bilateral mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="219">
               <a:s>valueset &quot;History of bilateral mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="220" locator="20:1-20:103" name="Mammography" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="220">
               <a:s>valueset &quot;Mammography&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="221" locator="21:1-21:119" name="Status Post Left Mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="221">
               <a:s>valueset &quot;Status Post Left Mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="222" locator="22:1-22:120" name="Status Post Right Mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="222">
               <a:s>valueset &quot;Status Post Right Mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="223" locator="23:1-23:118" name="Unilateral Mastectomy Left" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="223">
               <a:s>valueset &quot;Unilateral Mastectomy Left&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="224" locator="24:1-24:119" name="Unilateral Mastectomy Right" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="224">
               <a:s>valueset &quot;Unilateral Mastectomy Right&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="225" locator="25:1-25:137" name="Unilateral Mastectomy, Unspecified Laterality" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="225">
               <a:s>valueset &quot;Unilateral Mastectomy, Unspecified Laterality&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071'</a:s>
            </a:s>
         </annotation>
      </def>
   </valueSets>
   <codes>
      <def localId="226" locator="27:1-27:63" name="Female" id="F" display="Female" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="226">
               <a:s>code &quot;Female&quot;: 'F' from </a:s>
               <a:s r="227">
                  <a:s>&quot;AdministrativeGender&quot;</a:s>
               </a:s>
               <a:s> display 'Female'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="227" locator="27:25-27:46" name="AdministrativeGender"/>
      </def>
      <def localId="228" locator="28:1-28:89" name="Left (qualifier value)" id="7771000" display="Left (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="228">
               <a:s>code &quot;Left (qualifier value)&quot;: '7771000' from </a:s>
               <a:s r="229">
                  <a:s>&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Left (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="229" locator="28:47-28:56" name="SNOMEDCT"/>
      </def>
      <def localId="230" locator="29:1-29:92" name="Right (qualifier value)" id="24028007" display="Right (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="230">
               <a:s>code &quot;Right (qualifier value)&quot;: '24028007' from </a:s>
               <a:s r="231">
                  <a:s>&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Right (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="231" locator="29:49-29:58" name="SNOMEDCT"/>
      </def>
   </codes>
   <contexts>
      <def localId="238" locator="33:1-33:15" name="Patient"/>
   </contexts>
   <statements>
      <def localId="236" locator="33:1-33:15" name="Patient" context="Patient">
         <expression localId="237" xsi:type="SingletonFrom">
            <operand localId="235" locator="33:1-33:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="240" locator="35:1-40:64" name="Initial Population" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="240">
               <a:s>define &quot;Initial Population&quot;:
  </a:s>
               <a:s r="241">
                  <a:s r="242">
                     <a:s r="255">
                        <a:s r="251">
                           <a:s>AgeInYearsAt(</a:s>
                           <a:s r="243">
                              <a:s>date from 
    </a:s>
                              <a:s r="244">
                                 <a:s>end of </a:s>
                                 <a:s r="245">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
  )</a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="254">
                           <a:s r="252">Interval[52, 74]</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    and </a:s>
                     <a:s r="256">
                        <a:s r="259">
                           <a:s r="257">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="259">
                              <a:s>gender</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="260">
                           <a:s>'female'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    and </a:s>
                  <a:s r="261">
                     <a:s>exists </a:s>
                     <a:s r="263">
                        <a:s r="262">
                           <a:s>AdultOutpatientEncounters</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="263">
                           <a:s>&quot;Qualifying Encounters&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="241" locator="36:3-40:64" xsi:type="And">
            <operand localId="242" locator="36:3-39:33" xsi:type="And">
               <operand localId="255" locator="36:3-38:23" xsi:type="In">
                  <operand localId="251" locator="36:3-38:3" precision="Year" xsi:type="CalculateAgeAt">
                     <operand localId="250" path="value" xsi:type="Property">
                        <source localId="249" path="birthDate" xsi:type="Property">
                           <source localId="248" name="Patient" xsi:type="ExpressionRef"/>
                        </source>
                     </operand>
                     <operand localId="243" locator="36:16-37:31" xsi:type="DateFrom">
                        <operand localId="244" locator="37:5-37:31" xsi:type="End">
                           <operand localId="245" locator="37:12-37:31" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="254" locator="38:8-38:23" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="252" locator="38:17-38:18" valueType="t:Integer" value="52" xsi:type="Literal"/>
                     <high localId="253" locator="38:21-38:22" valueType="t:Integer" value="74" xsi:type="Literal"/>
                  </operand>
               </operand>
               <operand localId="256" locator="39:9-39:33" xsi:type="Equal">
                  <operand localId="259" locator="39:9-39:22" path="value" xsi:type="Property">
                     <source localId="258" path="gender" xsi:type="Property">
                        <source localId="257" locator="39:9-39:15" name="Patient" xsi:type="ExpressionRef"/>
                     </source>
                  </operand>
                  <operand localId="260" locator="39:26-39:33" valueType="t:String" value="female" xsi:type="Literal"/>
               </operand>
            </operand>
            <operand localId="261" locator="40:9-40:64" xsi:type="Exists">
               <operand localId="263" locator="40:16-40:64" name="Qualifying Encounters" libraryName="AdultOutpatientEncounters" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="265" locator="42:1-43:22" name="Denominator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="265">
               <a:s>define &quot;Denominator&quot;:
  </a:s>
               <a:s r="266">
                  <a:s>&quot;Initial Population&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="266" locator="43:3-43:22" name="Initial Population" xsi:type="ExpressionRef"/>
      </def>
      <def localId="281" locator="60:1-67:96" name="Right Mastectomy Diagnosis" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="281">
               <a:s>define &quot;Right Mastectomy Diagnosis&quot;:
  </a:s>
               <a:s r="317">
                  <a:s>
                     <a:s r="282">
                        <a:s r="310">
                           <a:s>( </a:s>
                           <a:s r="310">
                              <a:s r="288">
                                 <a:s>
                                    <a:s r="283">
                                       <a:s r="286">
                                          <a:s r="286">
                                             <a:s>[Condition: </a:s>
                                             <a:s>
                                                <a:s>&quot;Status Post Right Mastectomy&quot;</a:s>
                                             </a:s>
                                             <a:s>]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> RightMastectomyProcedure</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
    union </a:s>
                              <a:s r="309">
                                 <a:s>( </a:s>
                                 <a:s r="309">
                                    <a:s>
                                       <a:s r="289">
                                          <a:s r="292">
                                             <a:s r="292">
                                                <a:s>[Condition: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Unilateral Mastectomy, Unspecified Laterality&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> UnilateralMastectomyDiagnosis</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s r="294">
                                       <a:s>where </a:s>
                                       <a:s r="294">
                                          <a:s>exists </a:s>
                                          <a:s r="308">
                                             <a:s>( </a:s>
                                             <a:s r="308">
                                                <a:s>
                                                   <a:s r="295">
                                                      <a:s r="298">
                                                         <a:s>
                                                            <a:s>UnilateralMastectomyDiagnosis.bodySite</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s> S</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>
            </a:s>
                                                <a:s r="303">
                                                   <a:s>where </a:s>
                                                   <a:s r="303">
                                                      <a:s r="304">
                                                         <a:s>S</a:s>
                                                      </a:s>
                                                      <a:s> ~ </a:s>
                                                      <a:s r="305">
                                                         <a:s>&quot;Right (qualifier value)&quot;</a:s>
                                                      </a:s>
                                                   </a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
        )</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> RightMastectomy</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="316">
                     <a:s>where </a:s>
                     <a:s r="316">
                        <a:s r="312">
                           <a:s r="311">
                              <a:s>RightMastectomy</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="312">
                              <a:s>prevalenceInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="316"> starts on or before </a:s>
                        <a:s r="313">
                           <a:s>end of </a:s>
                           <a:s r="314">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="317" locator="61:3-67:96" xsi:type="Query">
            <source localId="282" locator="61:3-66:23" alias="RightMastectomy">
               <expression localId="310" locator="61:3-66:7" xsi:type="Union">
                  <operand localId="288" locator="61:5-61:72" xsi:type="Query">
                     <source localId="283" locator="61:5-61:72" alias="RightMastectomyProcedure">
                        <expression localId="286" locator="61:5-61:47" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="285" locator="61:17-61:46" name="Status Post Right Mastectomy" preserve="true" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                  </operand>
                  <operand localId="309" locator="62:11-66:5" xsi:type="Query">
                     <source localId="289" locator="62:13-62:102" alias="UnilateralMastectomyDiagnosis">
                        <expression localId="292" locator="62:13-62:72" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="291" locator="62:25-62:71" name="Unilateral Mastectomy, Unspecified Laterality" preserve="true" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="294" locator="63:9-65:9" xsi:type="Exists">
                        <operand localId="308" locator="63:22-65:9" xsi:type="Query">
                           <source localId="295" locator="63:24-63:63" alias="S">
                              <expression localId="298" locator="63:24-63:61" xsi:type="Query">
                                 <source localId="299" alias="$this">
                                    <expression localId="297" path="bodySite" scope="UnilateralMastectomyDiagnosis" xsi:type="Property"/>
                                 </source>
                                 <return localId="302" distinct="false">
                                    <expression localId="300" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="301" name="$this" xsi:type="AliasRef"/>
                                    </expression>
                                 </return>
                              </expression>
                           </source>
                           <where localId="303" locator="64:13-64:47" xsi:type="Equivalent">
                              <operand localId="304" locator="64:19" name="S" xsi:type="AliasRef"/>
                              <operand localId="307" xsi:type="ToConcept">
                                 <operand localId="305" locator="64:23-64:47" name="Right (qualifier value)" xsi:type="CodeRef"/>
                              </operand>
                           </where>
                        </operand>
                     </where>
                  </operand>
               </expression>
            </source>
            <where localId="316" locator="67:5-67:96" xsi:type="SameOrBefore">
               <operand localId="315" locator="67:50-67:55" xsi:type="Start">
                  <operand localId="312" locator="67:11-67:48" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="311" locator="67:11-67:25" name="RightMastectomy" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="313" locator="67:70-67:96" xsi:type="End">
                  <operand localId="314" locator="67:77-67:96" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="321" locator="69:1-71:115" name="Right Mastectomy Procedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="321">
               <a:s>define &quot;Right Mastectomy Procedure&quot;:
  </a:s>
               <a:s r="336">
                  <a:s>
                     <a:s r="322">
                        <a:s r="327">
                           <a:s>( </a:s>
                           <a:s r="327">
                              <a:s r="325">
                                 <a:s>( </a:s>
                                 <a:s r="325">
                                    <a:s>[Procedure: </a:s>
                                    <a:s>
                                       <a:s>&quot;Unilateral Mastectomy Right&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="327">
                                 <a:s>isProcedurePerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> UnilateralMastectomyRightPerformed</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="335">
                     <a:s>where </a:s>
                     <a:s r="335">
                        <a:s r="331">
                           <a:s r="330">
                              <a:s r="328">
                                 <a:s>UnilateralMastectomyRightPerformed</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="330">
                                 <a:s>performed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="331">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="335"> ends on or before </a:s>
                        <a:s r="332">
                           <a:s>end of </a:s>
                           <a:s r="333">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="336" locator="70:3-71:115" xsi:type="Query">
            <source localId="322" locator="70:3-70:112" alias="UnilateralMastectomyRightPerformed">
               <expression localId="327" locator="70:3-70:77" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="325" locator="70:5-70:50" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="324" locator="70:19-70:47" name="Unilateral Mastectomy Right" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="335" locator="71:5-71:115" xsi:type="SameOrBefore">
               <operand localId="334" locator="71:71-71:74" xsi:type="End">
                  <operand localId="331" locator="71:11-71:69" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="330" locator="71:11-71:54" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="329" path="performed" scope="UnilateralMastectomyRightPerformed" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="332" locator="71:89-71:115" xsi:type="End">
                  <operand localId="333" locator="71:96-71:115" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="341" locator="73:1-80:95" name="Left Mastectomy Diagnosis" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="341">
               <a:s>define &quot;Left Mastectomy Diagnosis&quot;:
  </a:s>
               <a:s r="375">
                  <a:s>
                     <a:s r="342">
                        <a:s r="368">
                           <a:s>( </a:s>
                           <a:s r="368">
                              <a:s r="345">
                                 <a:s>[Condition: </a:s>
                                 <a:s>
                                    <a:s>&quot;Status Post Left Mastectomy&quot;</a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                              <a:s>
    union </a:s>
                              <a:s r="367">
                                 <a:s>( </a:s>
                                 <a:s r="367">
                                    <a:s>
                                       <a:s r="347">
                                          <a:s r="350">
                                             <a:s r="350">
                                                <a:s>[Condition: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Unilateral Mastectomy, Unspecified Laterality&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> UnilateralMastectomyDiagnosis</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s r="352">
                                       <a:s>where </a:s>
                                       <a:s r="352">
                                          <a:s>exists </a:s>
                                          <a:s r="366">
                                             <a:s>( </a:s>
                                             <a:s r="366">
                                                <a:s>
                                                   <a:s r="353">
                                                      <a:s r="356">
                                                         <a:s>
                                                            <a:s>UnilateralMastectomyDiagnosis.bodySite</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s> S</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>
            </a:s>
                                                <a:s r="361">
                                                   <a:s>where </a:s>
                                                   <a:s r="361">
                                                      <a:s r="362">
                                                         <a:s>S</a:s>
                                                      </a:s>
                                                      <a:s> ~ </a:s>
                                                      <a:s r="363">
                                                         <a:s>&quot;Left (qualifier value)&quot;</a:s>
                                                      </a:s>
                                                   </a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
        )</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> LeftMastectomy</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="374">
                     <a:s>where </a:s>
                     <a:s r="374">
                        <a:s r="370">
                           <a:s r="369">
                              <a:s>LeftMastectomy</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="370">
                              <a:s>prevalenceInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="374"> starts on or before </a:s>
                        <a:s r="371">
                           <a:s>end of </a:s>
                           <a:s r="372">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="375" locator="74:3-80:95" xsi:type="Query">
            <source localId="342" locator="74:3-79:22" alias="LeftMastectomy">
               <expression localId="368" locator="74:3-79:7" xsi:type="Union">
                  <operand localId="345" locator="74:5-74:46" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="344" locator="74:17-74:45" name="Status Post Left Mastectomy" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
                  <operand localId="367" locator="75:11-79:5" xsi:type="Query">
                     <source localId="347" locator="75:13-75:102" alias="UnilateralMastectomyDiagnosis">
                        <expression localId="350" locator="75:13-75:72" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="349" locator="75:25-75:71" name="Unilateral Mastectomy, Unspecified Laterality" preserve="true" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="352" locator="76:9-78:9" xsi:type="Exists">
                        <operand localId="366" locator="76:22-78:9" xsi:type="Query">
                           <source localId="353" locator="76:24-76:63" alias="S">
                              <expression localId="356" locator="76:24-76:61" xsi:type="Query">
                                 <source localId="357" alias="$this">
                                    <expression localId="355" path="bodySite" scope="UnilateralMastectomyDiagnosis" xsi:type="Property"/>
                                 </source>
                                 <return localId="360" distinct="false">
                                    <expression localId="358" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="359" name="$this" xsi:type="AliasRef"/>
                                    </expression>
                                 </return>
                              </expression>
                           </source>
                           <where localId="361" locator="77:13-77:46" xsi:type="Equivalent">
                              <operand localId="362" locator="77:19" name="S" xsi:type="AliasRef"/>
                              <operand localId="365" xsi:type="ToConcept">
                                 <operand localId="363" locator="77:23-77:46" name="Left (qualifier value)" xsi:type="CodeRef"/>
                              </operand>
                           </where>
                        </operand>
                     </where>
                  </operand>
               </expression>
            </source>
            <where localId="374" locator="80:5-80:95" xsi:type="SameOrBefore">
               <operand localId="373" locator="80:49-80:54" xsi:type="Start">
                  <operand localId="370" locator="80:11-80:47" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="369" locator="80:11-80:24" name="LeftMastectomy" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="371" locator="80:69-80:95" xsi:type="End">
                  <operand localId="372" locator="80:76-80:95" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="379" locator="82:1-84:114" name="Left Mastectomy Procedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="379">
               <a:s>define &quot;Left Mastectomy Procedure&quot;:
  </a:s>
               <a:s r="394">
                  <a:s>
                     <a:s r="380">
                        <a:s r="385">
                           <a:s>( </a:s>
                           <a:s r="385">
                              <a:s r="383">
                                 <a:s>( </a:s>
                                 <a:s r="383">
                                    <a:s>[Procedure: </a:s>
                                    <a:s>
                                       <a:s>&quot;Unilateral Mastectomy Left&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="385">
                                 <a:s>isProcedurePerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> UnilateralMastectomyLeftPerformed</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="393">
                     <a:s>where </a:s>
                     <a:s r="393">
                        <a:s r="389">
                           <a:s r="388">
                              <a:s r="386">
                                 <a:s>UnilateralMastectomyLeftPerformed</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="388">
                                 <a:s>performed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="389">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="393"> ends on or before </a:s>
                        <a:s r="390">
                           <a:s>end of </a:s>
                           <a:s r="391">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="394" locator="83:3-84:114" xsi:type="Query">
            <source localId="380" locator="83:3-83:110" alias="UnilateralMastectomyLeftPerformed">
               <expression localId="385" locator="83:3-83:76" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="383" locator="83:5-83:49" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="382" locator="83:19-83:46" name="Unilateral Mastectomy Left" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="393" locator="84:5-84:114" xsi:type="SameOrBefore">
               <operand localId="392" locator="84:70-84:73" xsi:type="End">
                  <operand localId="389" locator="84:11-84:68" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="388" locator="84:11-84:53" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="387" path="performed" scope="UnilateralMastectomyLeftPerformed" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="390" locator="84:88-84:114" xsi:type="End">
                  <operand localId="391" locator="84:95-84:114" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="398" locator="86:1-88:107" name="Bilateral Mastectomy Diagnosis" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="398">
               <a:s>define &quot;Bilateral Mastectomy Diagnosis&quot;:
  </a:s>
               <a:s r="410">
                  <a:s>
                     <a:s r="399">
                        <a:s r="402">
                           <a:s r="402">
                              <a:s>[Condition: </a:s>
                              <a:s>
                                 <a:s>&quot;History of bilateral mastectomy&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> BilateralMastectomyHistory</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="409">
                     <a:s>where </a:s>
                     <a:s r="409">
                        <a:s r="405">
                           <a:s r="404">
                              <a:s>BilateralMastectomyHistory</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="405">
                              <a:s>prevalenceInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="409"> starts on or before </a:s>
                        <a:s r="406">
                           <a:s>end of </a:s>
                           <a:s r="407">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="410" locator="87:3-88:107" xsi:type="Query">
            <source localId="399" locator="87:3-87:75" alias="BilateralMastectomyHistory">
               <expression localId="402" locator="87:3-87:48" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                  <codes localId="401" locator="87:15-87:47" name="History of bilateral mastectomy" preserve="true" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="409" locator="88:5-88:107" xsi:type="SameOrBefore">
               <operand localId="408" locator="88:61-88:66" xsi:type="Start">
                  <operand localId="405" locator="88:11-88:59" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="404" locator="88:11-88:36" name="BilateralMastectomyHistory" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="406" locator="88:81-88:107" xsi:type="End">
                  <operand localId="407" locator="88:88-88:107" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="414" locator="90:1-92:109" name="Bilateral Mastectomy Procedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="414">
               <a:s>define &quot;Bilateral Mastectomy Procedure&quot;:
  </a:s>
               <a:s r="429">
                  <a:s>
                     <a:s r="415">
                        <a:s r="420">
                           <a:s>( </a:s>
                           <a:s r="420">
                              <a:s r="418">
                                 <a:s>( </a:s>
                                 <a:s r="418">
                                    <a:s>[Procedure: </a:s>
                                    <a:s>
                                       <a:s>&quot;Bilateral Mastectomy&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="420">
                                 <a:s>isProcedurePerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> BilateralMastectomyPerformed</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="428">
                     <a:s>where </a:s>
                     <a:s r="428">
                        <a:s r="424">
                           <a:s r="423">
                              <a:s r="421">
                                 <a:s>BilateralMastectomyPerformed</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="423">
                                 <a:s>performed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="424">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="428"> ends on or before </a:s>
                        <a:s r="425">
                           <a:s>end of </a:s>
                           <a:s r="426">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="429" locator="91:3-92:109" xsi:type="Query">
            <source localId="415" locator="91:3-91:99" alias="BilateralMastectomyPerformed">
               <expression localId="420" locator="91:3-91:70" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="418" locator="91:5-91:43" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="417" locator="91:19-91:40" name="Bilateral Mastectomy" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="428" locator="92:5-92:109" xsi:type="SameOrBefore">
               <operand localId="427" locator="92:65-92:68" xsi:type="End">
                  <operand localId="424" locator="92:11-92:63" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="423" locator="92:11-92:48" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="422" path="performed" scope="BilateralMastectomyPerformed" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="425" locator="92:83-92:109" xsi:type="End">
                  <operand localId="426" locator="92:90-92:109" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="268" locator="45:1-58:69" name="Denominator Exclusions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="268">
               <a:s>define &quot;Denominator Exclusions&quot;:
  </a:s>
               <a:s r="269">
                  <a:s r="270">
                     <a:s r="271">
                        <a:s r="272">
                           <a:s r="273">
                              <a:s r="274">
                                 <a:s r="276">
                                    <a:s r="275">
                                       <a:s>Hospice</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="276">
                                       <a:s>&quot;Has Hospice Services&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    or </a:s>
                                 <a:s r="277">
                                    <a:s>( </a:s>
                                    <a:s r="277">
                                       <a:s r="278">
                                          <a:s>( </a:s>
                                          <a:s r="278">
                                             <a:s r="279">
                                                <a:s>exists </a:s>
                                                <a:s r="318">
                                                   <a:s>( </a:s>
                                                   <a:s r="318">
                                                      <a:s>&quot;Right Mastectomy Diagnosis&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
          or </a:s>
                                             <a:s r="319">
                                                <a:s>exists </a:s>
                                                <a:s r="337">
                                                   <a:s>( </a:s>
                                                   <a:s r="337">
                                                      <a:s>&quot;Right Mastectomy Procedure&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
      )</a:s>
                                       </a:s>
                                       <a:s>
        and </a:s>
                                       <a:s r="338">
                                          <a:s>( </a:s>
                                          <a:s r="338">
                                             <a:s r="339">
                                                <a:s>exists </a:s>
                                                <a:s r="376">
                                                   <a:s>( </a:s>
                                                   <a:s r="376">
                                                      <a:s>&quot;Left Mastectomy Diagnosis&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
            or </a:s>
                                             <a:s r="377">
                                                <a:s>exists </a:s>
                                                <a:s r="395">
                                                   <a:s>( </a:s>
                                                   <a:s r="395">
                                                      <a:s>&quot;Left Mastectomy Procedure&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
        )</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
    )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
    or </a:s>
                              <a:s r="396">
                                 <a:s>exists </a:s>
                                 <a:s r="411">
                                    <a:s>&quot;Bilateral Mastectomy Diagnosis&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    or </a:s>
                           <a:s r="412">
                              <a:s>exists </a:s>
                              <a:s r="430">
                                 <a:s>&quot;Bilateral Mastectomy Procedure&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    or </a:s>
                        <a:s r="432">
                           <a:s r="431">
                              <a:s>AIFrailLTCF</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="432">
                              <a:s>&quot;Is Age 66 or Older with Advanced Illness and Frailty&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="434">
                        <a:s r="433">
                           <a:s>AIFrailLTCF</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="434">
                           <a:s>&quot;Is Age 66 or Older Living Long Term in a Nursing Home&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    or </a:s>
                  <a:s r="436">
                     <a:s r="435">
                        <a:s>PalliativeCare</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="436">
                        <a:s>&quot;Has Palliative Care in the Measurement Period&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="269" locator="46:3-58:69" xsi:type="Or">
            <operand localId="270" locator="46:3-57:74" xsi:type="Or">
               <operand localId="271" locator="46:3-56:73" xsi:type="Or">
                  <operand localId="272" locator="46:3-55:46" xsi:type="Or">
                     <operand localId="273" locator="46:3-54:46" xsi:type="Or">
                        <operand localId="274" locator="46:3-53:5" xsi:type="Or">
                           <operand localId="276" locator="46:3-46:32" name="Has Hospice Services" libraryName="Hospice" xsi:type="ExpressionRef"/>
                           <operand localId="277" locator="47:8-53:5" xsi:type="And">
                              <operand localId="278" locator="47:10-49:7" xsi:type="Or">
                                 <operand localId="279" locator="47:12-47:50" xsi:type="Exists">
                                    <operand localId="318" locator="47:19-47:50" name="Right Mastectomy Diagnosis" xsi:type="ExpressionRef"/>
                                 </operand>
                                 <operand localId="319" locator="48:14-48:52" xsi:type="Exists">
                                    <operand localId="337" locator="48:21-48:52" name="Right Mastectomy Procedure" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="338" locator="50:13-52:9" xsi:type="Or">
                                 <operand localId="339" locator="50:15-50:52" xsi:type="Exists">
                                    <operand localId="376" locator="50:22-50:52" name="Left Mastectomy Diagnosis" xsi:type="ExpressionRef"/>
                                 </operand>
                                 <operand localId="377" locator="51:16-51:53" xsi:type="Exists">
                                    <operand localId="395" locator="51:23-51:53" name="Left Mastectomy Procedure" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                           </operand>
                        </operand>
                        <operand localId="396" locator="54:8-54:46" xsi:type="Exists">
                           <operand localId="411" locator="54:15-54:46" name="Bilateral Mastectomy Diagnosis" xsi:type="ExpressionRef"/>
                        </operand>
                     </operand>
                     <operand localId="412" locator="55:8-55:46" xsi:type="Exists">
                        <operand localId="430" locator="55:15-55:46" name="Bilateral Mastectomy Procedure" xsi:type="ExpressionRef"/>
                     </operand>
                  </operand>
                  <operand localId="432" locator="56:8-56:73" name="Is Age 66 or Older with Advanced Illness and Frailty" libraryName="AIFrailLTCF" xsi:type="ExpressionRef"/>
               </operand>
               <operand localId="434" locator="57:8-57:74" name="Is Age 66 or Older Living Long Term in a Nursing Home" libraryName="AIFrailLTCF" xsi:type="ExpressionRef"/>
            </operand>
            <operand localId="436" locator="58:8-58:69" name="Has Palliative Care in the Measurement Period" libraryName="PalliativeCare" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="451" locator="99:1-100:79" name="October 1 Two Years Prior to the Measurement Period" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="451">
               <a:s>define &quot;October 1 Two Years Prior to the Measurement Period&quot;:
  </a:s>
               <a:s r="468">
                  <a:s>DateTime(</a:s>
                  <a:s r="452">
                     <a:s>(</a:s>
                     <a:s r="452">
                        <a:s r="453">
                           <a:s>year from </a:s>
                           <a:s r="454">
                              <a:s>start of </a:s>
                              <a:s r="455">
                                 <a:s>&quot;Measurement Period&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s r="456"> - 2</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
                  <a:s r="457">, 10, 1, 0, 0, 0, 0, 0)</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="468" locator="100:3-100:79" xsi:type="DateTime">
            <year localId="452" locator="100:12-100:56" xsi:type="Subtract">
               <operand localId="453" locator="100:13-100:51" precision="Year" xsi:type="DateTimeComponentFrom">
                  <operand localId="454" locator="100:23-100:51" xsi:type="Start">
                     <operand localId="455" locator="100:32-100:51" name="Measurement Period" xsi:type="ParameterRef"/>
                  </operand>
               </operand>
               <operand localId="456" locator="100:55" valueType="t:Integer" value="2" xsi:type="Literal"/>
            </year>
            <month localId="457" locator="100:59-100:60" valueType="t:Integer" value="10" xsi:type="Literal"/>
            <day localId="458" locator="100:63" valueType="t:Integer" value="1" xsi:type="Literal"/>
            <hour localId="459" locator="100:66" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <minute localId="460" locator="100:69" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <second localId="461" locator="100:72" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <millisecond localId="462" locator="100:75" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <timezoneOffset localId="470" xsi:type="ToDecimal">
               <operand localId="463" locator="100:78" valueType="t:Integer" value="0" xsi:type="Literal"/>
            </timezoneOffset>
         </expression>
      </def>
      <def localId="438" locator="94:1-97:3" name="Numerator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="438">
               <a:s>define &quot;Numerator&quot;:
  </a:s>
               <a:s r="439">
                  <a:s>exists </a:s>
                  <a:s r="477">
                     <a:s>( </a:s>
                     <a:s r="477">
                        <a:s>
                           <a:s r="440">
                              <a:s r="445">
                                 <a:s>( </a:s>
                                 <a:s r="445">
                                    <a:s r="443">
                                       <a:s>( </a:s>
                                       <a:s r="443">
                                          <a:s>[Observation: </a:s>
                                          <a:s>
                                             <a:s>&quot;Mammography&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                       <a:s> )</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="445">
                                       <a:s>isDiagnosticStudyPerformed ( )</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s> Mammogram</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="476">
                           <a:s>where </a:s>
                           <a:s r="476">
                              <a:s r="449">
                                 <a:s r="448">
                                    <a:s r="446">
                                       <a:s>Mammogram</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="448">
                                       <a:s>effective</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="449">
                                    <a:s>toInterval ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="476"> ends during day of </a:s>
                              <a:s r="474">
                                 <a:s>Interval[</a:s>
                                 <a:s r="471">
                                    <a:s>&quot;October 1 Two Years Prior to the Measurement Period&quot;</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="472">
                                    <a:s>end of </a:s>
                                    <a:s r="473">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="439" locator="95:3-97:3" xsi:type="Exists">
            <operand localId="477" locator="95:10-97:3" xsi:type="Query">
               <source localId="440" locator="95:12-95:88" alias="Mammogram">
                  <expression localId="445" locator="95:12-95:78" name="isDiagnosticStudyPerformed" libraryName="Status" xsi:type="FunctionRef">
                     <operand localId="443" locator="95:14-95:45" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                        <codes localId="442" locator="95:30-95:42" name="Mammography" preserve="true" xsi:type="ValueSetRef"/>
                     </operand>
                  </expression>
               </source>
               <where localId="476" locator="96:7-96:158" precision="Day" xsi:type="In">
                  <operand localId="475" locator="96:48-96:51" xsi:type="End">
                     <operand localId="449" locator="96:13-96:46" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                        <operand localId="448" locator="96:13-96:31" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="447" path="effective" scope="Mammogram" xsi:type="Property"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="474" locator="96:67-96:158" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="471" locator="96:76-96:128" name="October 1 Two Years Prior to the Measurement Period" xsi:type="ExpressionRef"/>
                     <high localId="472" locator="96:131-96:157" xsi:type="End">
                        <operand localId="473" locator="96:138-96:157" name="Measurement Period" xsi:type="ParameterRef"/>
                     </high>
                  </operand>
               </where>
            </operand>
         </expression>
      </def>
      <def localId="479" locator="102:1-103:21" name="SDE Ethnicity" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="479">
               <a:s>define &quot;SDE Ethnicity&quot;:
  </a:s>
               <a:s r="481">
                  <a:s r="480">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="481">
                     <a:s>&quot;SDE Ethnicity&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="481" locator="103:3-103:21" name="SDE Ethnicity" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="483" locator="105:1-106:17" name="SDE Payer" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="483">
               <a:s>define &quot;SDE Payer&quot;:
  </a:s>
               <a:s r="485">
                  <a:s r="484">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="485">
                     <a:s>&quot;SDE Payer&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="485" locator="106:3-106:17" name="SDE Payer" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="487" locator="108:1-109:16" name="SDE Race" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="487">
               <a:s>define &quot;SDE Race&quot;:
  </a:s>
               <a:s r="489">
                  <a:s r="488">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="489">
                     <a:s>&quot;SDE Race&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="489" locator="109:3-109:16" name="SDE Race" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="491" locator="111:1-112:15" name="SDE Sex" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="491">
               <a:s>define &quot;SDE Sex&quot;:
  </a:s>
               <a:s r="493">
                  <a:s r="492">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="493">
                     <a:s>&quot;SDE Sex&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="493" locator="112:3-112:15" name="SDE Sex" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
   </statements>
</library>
" + }, + { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "localId" : "0",
      "annotation" : [ {
         "translatorVersion" : "3.10.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "signatureLevel" : "None",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "s" : {
            "r" : "491",
            "s" : [ {
               "value" : [ "","library BreastCancerScreeningFHIR version '0.0.001'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "BreastCancerScreeningFHIR",
         "system" : "http://ecqi.healthit.gov/ecqms",
         "version" : "0.0.001"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localId" : "1",
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "206",
            "locator" : "3:1-3:28",
            "localIdentifier" : "QICore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "206",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICore" ]
                     } ]
                  }, {
                     "value" : [ " version '4.1.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "207",
            "locator" : "5:1-5:56",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://ecqi.healthit.gov/ecqms/FHIRHelpers",
            "version" : "4.4.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "207",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.4.000'"," called ","FHIRHelpers" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "208",
            "locator" : "6:1-6:61",
            "localIdentifier" : "SDE",
            "path" : "http://ecqi.healthit.gov/ecqms/SupplementalDataElements",
            "version" : "3.5.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "208",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "SupplementalDataElements" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.5.000'"," called ","SDE" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "209",
            "locator" : "7:1-7:58",
            "localIdentifier" : "QICoreCommon",
            "path" : "http://ecqi.healthit.gov/ecqms/QICoreCommon",
            "version" : "2.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "209",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'2.1.000'"," called ","QICoreCommon" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "210",
            "locator" : "8:1-8:85",
            "localIdentifier" : "AdultOutpatientEncounters",
            "path" : "http://ecqi.healthit.gov/ecqms/AdultOutpatientEncounters",
            "version" : "4.11.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "210",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "AdultOutpatientEncounters" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.11.000'"," called ","AdultOutpatientEncounters" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "211",
            "locator" : "9:1-9:49",
            "localIdentifier" : "Hospice",
            "path" : "http://ecqi.healthit.gov/ecqms/Hospice",
            "version" : "6.12.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "211",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Hospice" ]
                     } ]
                  }, {
                     "value" : [ " version ","'6.12.000'"," called ","Hospice" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "212",
            "locator" : "10:1-10:46",
            "localIdentifier" : "Status",
            "path" : "http://ecqi.healthit.gov/ecqms/Status",
            "version" : "1.8.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "212",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Status" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.8.000'"," called ","Status" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "213",
            "locator" : "11:1-11:63",
            "localIdentifier" : "PalliativeCare",
            "path" : "http://ecqi.healthit.gov/ecqms/PalliativeCare",
            "version" : "1.11.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "213",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "PalliativeCare" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.11.000'"," called ","PalliativeCare" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "214",
            "locator" : "12:1-12:71",
            "localIdentifier" : "AIFrailLTCF",
            "path" : "http://ecqi.healthit.gov/ecqms/AdvancedIllnessandFrailty",
            "version" : "1.16.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "214",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "AdvancedIllnessandFrailty" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.16.000'"," called ","AIFrailLTCF" ]
                  } ]
               }
            } ]
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "232",
            "locator" : "31:1-31:49",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "232",
                  "s" : [ {
                     "value" : [ "","parameter ","\"Measurement Period\""," " ]
                  }, {
                     "r" : "233",
                     "s" : [ {
                        "value" : [ "Interval<" ]
                     }, {
                        "r" : "234",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  } ]
               }
            } ],
            "parameterTypeSpecifier" : {
               "localId" : "233",
               "locator" : "31:32-31:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "234",
                  "locator" : "31:41-31:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "215",
            "locator" : "14:1-14:98",
            "name" : "AdministrativeGender",
            "id" : "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "215",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"AdministrativeGender\"",": ","'http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "216",
            "locator" : "15:1-15:47",
            "name" : "SNOMEDCT",
            "id" : "http://snomed.info/sct",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "216",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"SNOMEDCT\"",": ","'http://snomed.info/sct'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "217",
            "locator" : "16:1-16:38",
            "name" : "LOINC",
            "id" : "http://loinc.org",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "217",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"LOINC\"",": ","'http://loinc.org'" ]
                  } ]
               }
            } ]
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "218",
            "locator" : "18:1-18:112",
            "name" : "Bilateral Mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "218",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Bilateral Mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "219",
            "locator" : "19:1-19:123",
            "name" : "History of bilateral mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "219",
                  "s" : [ {
                     "value" : [ "","valueset ","\"History of bilateral mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "220",
            "locator" : "20:1-20:103",
            "name" : "Mammography",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "220",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Mammography\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "221",
            "locator" : "21:1-21:119",
            "name" : "Status Post Left Mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "221",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Status Post Left Mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "222",
            "locator" : "22:1-22:120",
            "name" : "Status Post Right Mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "222",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Status Post Right Mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "223",
            "locator" : "23:1-23:118",
            "name" : "Unilateral Mastectomy Left",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "223",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Unilateral Mastectomy Left\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "224",
            "locator" : "24:1-24:119",
            "name" : "Unilateral Mastectomy Right",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "224",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Unilateral Mastectomy Right\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "225",
            "locator" : "25:1-25:137",
            "name" : "Unilateral Mastectomy, Unspecified Laterality",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "225",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Unilateral Mastectomy, Unspecified Laterality\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "226",
            "locator" : "27:1-27:63",
            "name" : "Female",
            "id" : "F",
            "display" : "Female",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "226",
                  "s" : [ {
                     "value" : [ "","code ","\"Female\"",": ","'F'"," from " ]
                  }, {
                     "r" : "227",
                     "s" : [ {
                        "value" : [ "\"AdministrativeGender\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Female'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "227",
               "locator" : "27:25-27:46",
               "name" : "AdministrativeGender"
            }
         }, {
            "localId" : "228",
            "locator" : "28:1-28:89",
            "name" : "Left (qualifier value)",
            "id" : "7771000",
            "display" : "Left (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "228",
                  "s" : [ {
                     "value" : [ "","code ","\"Left (qualifier value)\"",": ","'7771000'"," from " ]
                  }, {
                     "r" : "229",
                     "s" : [ {
                        "value" : [ "\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Left (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "229",
               "locator" : "28:47-28:56",
               "name" : "SNOMEDCT"
            }
         }, {
            "localId" : "230",
            "locator" : "29:1-29:92",
            "name" : "Right (qualifier value)",
            "id" : "24028007",
            "display" : "Right (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "230",
                  "s" : [ {
                     "value" : [ "","code ","\"Right (qualifier value)\"",": ","'24028007'"," from " ]
                  }, {
                     "r" : "231",
                     "s" : [ {
                        "value" : [ "\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Right (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "231",
               "locator" : "29:49-29:58",
               "name" : "SNOMEDCT"
            }
         } ]
      },
      "contexts" : {
         "def" : [ {
            "localId" : "238",
            "locator" : "33:1-33:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "localId" : "236",
            "locator" : "33:1-33:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "localId" : "237",
               "type" : "SingletonFrom",
               "signature" : [ ],
               "operand" : {
                  "localId" : "235",
                  "locator" : "33:1-33:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient",
                  "type" : "Retrieve",
                  "include" : [ ],
                  "codeFilter" : [ ],
                  "dateFilter" : [ ],
                  "otherFilter" : [ ]
               }
            }
         }, {
            "localId" : "240",
            "locator" : "35:1-40:64",
            "name" : "Initial Population",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "240",
                  "s" : [ {
                     "value" : [ "","define ","\"Initial Population\"",":\n  " ]
                  }, {
                     "r" : "241",
                     "s" : [ {
                        "r" : "242",
                        "s" : [ {
                           "r" : "255",
                           "s" : [ {
                              "r" : "251",
                              "s" : [ {
                                 "value" : [ "AgeInYearsAt","(" ]
                              }, {
                                 "r" : "243",
                                 "s" : [ {
                                    "value" : [ "date from \n    " ]
                                 }, {
                                    "r" : "244",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "245",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n  )" ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "254",
                              "s" : [ {
                                 "r" : "252",
                                 "value" : [ "Interval[","52",", ","74","]" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    and " ]
                        }, {
                           "r" : "256",
                           "s" : [ {
                              "r" : "259",
                              "s" : [ {
                                 "r" : "257",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "259",
                                 "s" : [ {
                                    "value" : [ "gender" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "260",
                              "s" : [ {
                                 "value" : [ "'female'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    and " ]
                     }, {
                        "r" : "261",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "263",
                           "s" : [ {
                              "r" : "262",
                              "s" : [ {
                                 "value" : [ "AdultOutpatientEncounters" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "263",
                              "s" : [ {
                                 "value" : [ "\"Qualifying Encounters\"" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "241",
               "locator" : "36:3-40:64",
               "type" : "And",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "242",
                  "locator" : "36:3-39:33",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "255",
                     "locator" : "36:3-38:23",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "251",
                        "locator" : "36:3-38:3",
                        "precision" : "Year",
                        "type" : "CalculateAgeAt",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "250",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "249",
                              "path" : "birthDate",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "248",
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           }
                        }, {
                           "localId" : "243",
                           "locator" : "36:16-37:31",
                           "type" : "DateFrom",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "244",
                              "locator" : "37:5-37:31",
                              "type" : "End",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "245",
                                 "locator" : "37:12-37:31",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "localId" : "254",
                        "locator" : "38:8-38:23",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "252",
                           "locator" : "38:17-38:18",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "52",
                           "type" : "Literal"
                        },
                        "high" : {
                           "localId" : "253",
                           "locator" : "38:21-38:22",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "74",
                           "type" : "Literal"
                        }
                     } ]
                  }, {
                     "localId" : "256",
                     "locator" : "39:9-39:33",
                     "type" : "Equal",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "259",
                        "locator" : "39:9-39:22",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "258",
                           "path" : "gender",
                           "type" : "Property",
                           "source" : {
                              "localId" : "257",
                              "locator" : "39:9-39:15",
                              "name" : "Patient",
                              "type" : "ExpressionRef"
                           }
                        }
                     }, {
                        "localId" : "260",
                        "locator" : "39:26-39:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "female",
                        "type" : "Literal"
                     } ]
                  } ]
               }, {
                  "localId" : "261",
                  "locator" : "40:9-40:64",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "263",
                     "locator" : "40:16-40:64",
                     "name" : "Qualifying Encounters",
                     "libraryName" : "AdultOutpatientEncounters",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "265",
            "locator" : "42:1-43:22",
            "name" : "Denominator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "265",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator\"",":\n  " ]
                  }, {
                     "r" : "266",
                     "s" : [ {
                        "value" : [ "\"Initial Population\"" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "266",
               "locator" : "43:3-43:22",
               "name" : "Initial Population",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "281",
            "locator" : "60:1-67:96",
            "name" : "Right Mastectomy Diagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "281",
                  "s" : [ {
                     "value" : [ "","define ","\"Right Mastectomy Diagnosis\"",":\n  " ]
                  }, {
                     "r" : "317",
                     "s" : [ {
                        "s" : [ {
                           "r" : "282",
                           "s" : [ {
                              "r" : "310",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "310",
                                 "s" : [ {
                                    "r" : "288",
                                    "s" : [ {
                                       "s" : [ {
                                          "r" : "283",
                                          "s" : [ {
                                             "r" : "286",
                                             "s" : [ {
                                                "r" : "286",
                                                "s" : [ {
                                                   "value" : [ "[","Condition",": " ]
                                                }, {
                                                   "s" : [ {
                                                      "value" : [ "\"Status Post Right Mastectomy\"" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","RightMastectomyProcedure" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    union " ]
                                 }, {
                                    "r" : "309",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "309",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "289",
                                             "s" : [ {
                                                "r" : "292",
                                                "s" : [ {
                                                   "r" : "292",
                                                   "s" : [ {
                                                      "value" : [ "[","Condition",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Unilateral Mastectomy, Unspecified Laterality\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","UnilateralMastectomyDiagnosis" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "r" : "294",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "294",
                                             "s" : [ {
                                                "value" : [ "exists " ]
                                             }, {
                                                "r" : "308",
                                                "s" : [ {
                                                   "value" : [ "( " ]
                                                }, {
                                                   "r" : "308",
                                                   "s" : [ {
                                                      "s" : [ {
                                                         "r" : "295",
                                                         "s" : [ {
                                                            "r" : "298",
                                                            "s" : [ {
                                                               "s" : [ {
                                                                  "value" : [ "UnilateralMastectomyDiagnosis",".","bodySite" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","S" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n            " ]
                                                   }, {
                                                      "r" : "303",
                                                      "s" : [ {
                                                         "value" : [ "where " ]
                                                      }, {
                                                         "r" : "303",
                                                         "s" : [ {
                                                            "r" : "304",
                                                            "s" : [ {
                                                               "value" : [ "S" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","~"," " ]
                                                         }, {
                                                            "r" : "305",
                                                            "s" : [ {
                                                               "value" : [ "\"Right (qualifier value)\"" ]
                                                            } ]
                                                         } ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n        )" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","RightMastectomy" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "316",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "316",
                           "s" : [ {
                              "r" : "312",
                              "s" : [ {
                                 "r" : "311",
                                 "s" : [ {
                                    "value" : [ "RightMastectomy" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "312",
                                 "s" : [ {
                                    "value" : [ "prevalenceInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "316",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "313",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "314",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "317",
               "locator" : "61:3-67:96",
               "type" : "Query",
               "source" : [ {
                  "localId" : "282",
                  "locator" : "61:3-66:23",
                  "alias" : "RightMastectomy",
                  "expression" : {
                     "localId" : "310",
                     "locator" : "61:3-66:7",
                     "type" : "Union",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "288",
                        "locator" : "61:5-61:72",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "283",
                           "locator" : "61:5-61:72",
                           "alias" : "RightMastectomyProcedure",
                           "expression" : {
                              "localId" : "286",
                              "locator" : "61:5-61:47",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "285",
                                 "locator" : "61:17-61:46",
                                 "name" : "Status Post Right Mastectomy",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }
                        } ],
                        "let" : [ ],
                        "relationship" : [ ]
                     }, {
                        "localId" : "309",
                        "locator" : "62:11-66:5",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "289",
                           "locator" : "62:13-62:102",
                           "alias" : "UnilateralMastectomyDiagnosis",
                           "expression" : {
                              "localId" : "292",
                              "locator" : "62:13-62:72",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "291",
                                 "locator" : "62:25-62:71",
                                 "name" : "Unilateral Mastectomy, Unspecified Laterality",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }
                        } ],
                        "let" : [ ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "294",
                           "locator" : "63:9-65:9",
                           "type" : "Exists",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "308",
                              "locator" : "63:22-65:9",
                              "type" : "Query",
                              "source" : [ {
                                 "localId" : "295",
                                 "locator" : "63:24-63:63",
                                 "alias" : "S",
                                 "expression" : {
                                    "localId" : "298",
                                    "locator" : "63:24-63:61",
                                    "type" : "Query",
                                    "source" : [ {
                                       "localId" : "299",
                                       "alias" : "$this",
                                       "expression" : {
                                          "localId" : "297",
                                          "path" : "bodySite",
                                          "scope" : "UnilateralMastectomyDiagnosis",
                                          "type" : "Property"
                                       }
                                    } ],
                                    "let" : [ ],
                                    "relationship" : [ ],
                                    "return" : {
                                       "localId" : "302",
                                       "distinct" : false,
                                       "expression" : {
                                          "localId" : "300",
                                          "name" : "ToConcept",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "301",
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          } ]
                                       }
                                    }
                                 }
                              } ],
                              "let" : [ ],
                              "relationship" : [ ],
                              "where" : {
                                 "localId" : "303",
                                 "locator" : "64:13-64:47",
                                 "type" : "Equivalent",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "304",
                                    "locator" : "64:19",
                                    "name" : "S",
                                    "type" : "AliasRef"
                                 }, {
                                    "localId" : "307",
                                    "type" : "ToConcept",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "305",
                                       "locator" : "64:23-64:47",
                                       "name" : "Right (qualifier value)",
                                       "type" : "CodeRef"
                                    }
                                 } ]
                              }
                           }
                        }
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "316",
                  "locator" : "67:5-67:96",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "315",
                     "locator" : "67:50-67:55",
                     "type" : "Start",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "312",
                        "locator" : "67:11-67:48",
                        "name" : "prevalenceInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "311",
                           "locator" : "67:11-67:25",
                           "name" : "RightMastectomy",
                           "type" : "AliasRef"
                        } ]
                     }
                  }, {
                     "localId" : "313",
                     "locator" : "67:70-67:96",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "314",
                        "locator" : "67:77-67:96",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "321",
            "locator" : "69:1-71:115",
            "name" : "Right Mastectomy Procedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "321",
                  "s" : [ {
                     "value" : [ "","define ","\"Right Mastectomy Procedure\"",":\n  " ]
                  }, {
                     "r" : "336",
                     "s" : [ {
                        "s" : [ {
                           "r" : "322",
                           "s" : [ {
                              "r" : "327",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "327",
                                 "s" : [ {
                                    "r" : "325",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "325",
                                       "s" : [ {
                                          "value" : [ "[","Procedure",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Unilateral Mastectomy Right\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "327",
                                    "s" : [ {
                                       "value" : [ "isProcedurePerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","UnilateralMastectomyRightPerformed" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "335",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "335",
                           "s" : [ {
                              "r" : "331",
                              "s" : [ {
                                 "r" : "330",
                                 "s" : [ {
                                    "r" : "328",
                                    "s" : [ {
                                       "value" : [ "UnilateralMastectomyRightPerformed" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "330",
                                    "s" : [ {
                                       "value" : [ "performed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "331",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "335",
                              "value" : [ " ","ends on or before"," " ]
                           }, {
                              "r" : "332",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "333",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "336",
               "locator" : "70:3-71:115",
               "type" : "Query",
               "source" : [ {
                  "localId" : "322",
                  "locator" : "70:3-70:112",
                  "alias" : "UnilateralMastectomyRightPerformed",
                  "expression" : {
                     "localId" : "327",
                     "locator" : "70:3-70:77",
                     "name" : "isProcedurePerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "325",
                        "locator" : "70:5-70:50",
                        "dataType" : "{http://hl7.org/fhir}Procedure",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "324",
                           "locator" : "70:19-70:47",
                           "name" : "Unilateral Mastectomy Right",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "335",
                  "locator" : "71:5-71:115",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "334",
                     "locator" : "71:71-71:74",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "331",
                        "locator" : "71:11-71:69",
                        "name" : "toInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "330",
                           "locator" : "71:11-71:54",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "329",
                              "path" : "performed",
                              "scope" : "UnilateralMastectomyRightPerformed",
                              "type" : "Property"
                           } ]
                        } ]
                     }
                  }, {
                     "localId" : "332",
                     "locator" : "71:89-71:115",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "333",
                        "locator" : "71:96-71:115",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "341",
            "locator" : "73:1-80:95",
            "name" : "Left Mastectomy Diagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "341",
                  "s" : [ {
                     "value" : [ "","define ","\"Left Mastectomy Diagnosis\"",":\n  " ]
                  }, {
                     "r" : "375",
                     "s" : [ {
                        "s" : [ {
                           "r" : "342",
                           "s" : [ {
                              "r" : "368",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "368",
                                 "s" : [ {
                                    "r" : "345",
                                    "s" : [ {
                                       "value" : [ "[","Condition",": " ]
                                    }, {
                                       "s" : [ {
                                          "value" : [ "\"Status Post Left Mastectomy\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    union " ]
                                 }, {
                                    "r" : "367",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "367",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "347",
                                             "s" : [ {
                                                "r" : "350",
                                                "s" : [ {
                                                   "r" : "350",
                                                   "s" : [ {
                                                      "value" : [ "[","Condition",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Unilateral Mastectomy, Unspecified Laterality\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","UnilateralMastectomyDiagnosis" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "r" : "352",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "352",
                                             "s" : [ {
                                                "value" : [ "exists " ]
                                             }, {
                                                "r" : "366",
                                                "s" : [ {
                                                   "value" : [ "( " ]
                                                }, {
                                                   "r" : "366",
                                                   "s" : [ {
                                                      "s" : [ {
                                                         "r" : "353",
                                                         "s" : [ {
                                                            "r" : "356",
                                                            "s" : [ {
                                                               "s" : [ {
                                                                  "value" : [ "UnilateralMastectomyDiagnosis",".","bodySite" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","S" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n            " ]
                                                   }, {
                                                      "r" : "361",
                                                      "s" : [ {
                                                         "value" : [ "where " ]
                                                      }, {
                                                         "r" : "361",
                                                         "s" : [ {
                                                            "r" : "362",
                                                            "s" : [ {
                                                               "value" : [ "S" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","~"," " ]
                                                         }, {
                                                            "r" : "363",
                                                            "s" : [ {
                                                               "value" : [ "\"Left (qualifier value)\"" ]
                                                            } ]
                                                         } ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n        )" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","LeftMastectomy" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "374",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "374",
                           "s" : [ {
                              "r" : "370",
                              "s" : [ {
                                 "r" : "369",
                                 "s" : [ {
                                    "value" : [ "LeftMastectomy" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "370",
                                 "s" : [ {
                                    "value" : [ "prevalenceInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "374",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "371",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "372",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "375",
               "locator" : "74:3-80:95",
               "type" : "Query",
               "source" : [ {
                  "localId" : "342",
                  "locator" : "74:3-79:22",
                  "alias" : "LeftMastectomy",
                  "expression" : {
                     "localId" : "368",
                     "locator" : "74:3-79:7",
                     "type" : "Union",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "345",
                        "locator" : "74:5-74:46",
                        "dataType" : "{http://hl7.org/fhir}Condition",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "344",
                           "locator" : "74:17-74:45",
                           "name" : "Status Post Left Mastectomy",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     }, {
                        "localId" : "367",
                        "locator" : "75:11-79:5",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "347",
                           "locator" : "75:13-75:102",
                           "alias" : "UnilateralMastectomyDiagnosis",
                           "expression" : {
                              "localId" : "350",
                              "locator" : "75:13-75:72",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "349",
                                 "locator" : "75:25-75:71",
                                 "name" : "Unilateral Mastectomy, Unspecified Laterality",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }
                        } ],
                        "let" : [ ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "352",
                           "locator" : "76:9-78:9",
                           "type" : "Exists",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "366",
                              "locator" : "76:22-78:9",
                              "type" : "Query",
                              "source" : [ {
                                 "localId" : "353",
                                 "locator" : "76:24-76:63",
                                 "alias" : "S",
                                 "expression" : {
                                    "localId" : "356",
                                    "locator" : "76:24-76:61",
                                    "type" : "Query",
                                    "source" : [ {
                                       "localId" : "357",
                                       "alias" : "$this",
                                       "expression" : {
                                          "localId" : "355",
                                          "path" : "bodySite",
                                          "scope" : "UnilateralMastectomyDiagnosis",
                                          "type" : "Property"
                                       }
                                    } ],
                                    "let" : [ ],
                                    "relationship" : [ ],
                                    "return" : {
                                       "localId" : "360",
                                       "distinct" : false,
                                       "expression" : {
                                          "localId" : "358",
                                          "name" : "ToConcept",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "359",
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          } ]
                                       }
                                    }
                                 }
                              } ],
                              "let" : [ ],
                              "relationship" : [ ],
                              "where" : {
                                 "localId" : "361",
                                 "locator" : "77:13-77:46",
                                 "type" : "Equivalent",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "362",
                                    "locator" : "77:19",
                                    "name" : "S",
                                    "type" : "AliasRef"
                                 }, {
                                    "localId" : "365",
                                    "type" : "ToConcept",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "363",
                                       "locator" : "77:23-77:46",
                                       "name" : "Left (qualifier value)",
                                       "type" : "CodeRef"
                                    }
                                 } ]
                              }
                           }
                        }
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "374",
                  "locator" : "80:5-80:95",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "373",
                     "locator" : "80:49-80:54",
                     "type" : "Start",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "370",
                        "locator" : "80:11-80:47",
                        "name" : "prevalenceInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "369",
                           "locator" : "80:11-80:24",
                           "name" : "LeftMastectomy",
                           "type" : "AliasRef"
                        } ]
                     }
                  }, {
                     "localId" : "371",
                     "locator" : "80:69-80:95",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "372",
                        "locator" : "80:76-80:95",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "379",
            "locator" : "82:1-84:114",
            "name" : "Left Mastectomy Procedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "379",
                  "s" : [ {
                     "value" : [ "","define ","\"Left Mastectomy Procedure\"",":\n  " ]
                  }, {
                     "r" : "394",
                     "s" : [ {
                        "s" : [ {
                           "r" : "380",
                           "s" : [ {
                              "r" : "385",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "385",
                                 "s" : [ {
                                    "r" : "383",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "383",
                                       "s" : [ {
                                          "value" : [ "[","Procedure",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Unilateral Mastectomy Left\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "385",
                                    "s" : [ {
                                       "value" : [ "isProcedurePerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","UnilateralMastectomyLeftPerformed" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "393",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "393",
                           "s" : [ {
                              "r" : "389",
                              "s" : [ {
                                 "r" : "388",
                                 "s" : [ {
                                    "r" : "386",
                                    "s" : [ {
                                       "value" : [ "UnilateralMastectomyLeftPerformed" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "388",
                                    "s" : [ {
                                       "value" : [ "performed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "389",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "393",
                              "value" : [ " ","ends on or before"," " ]
                           }, {
                              "r" : "390",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "391",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "394",
               "locator" : "83:3-84:114",
               "type" : "Query",
               "source" : [ {
                  "localId" : "380",
                  "locator" : "83:3-83:110",
                  "alias" : "UnilateralMastectomyLeftPerformed",
                  "expression" : {
                     "localId" : "385",
                     "locator" : "83:3-83:76",
                     "name" : "isProcedurePerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "383",
                        "locator" : "83:5-83:49",
                        "dataType" : "{http://hl7.org/fhir}Procedure",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "382",
                           "locator" : "83:19-83:46",
                           "name" : "Unilateral Mastectomy Left",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "393",
                  "locator" : "84:5-84:114",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "392",
                     "locator" : "84:70-84:73",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "389",
                        "locator" : "84:11-84:68",
                        "name" : "toInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "388",
                           "locator" : "84:11-84:53",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "387",
                              "path" : "performed",
                              "scope" : "UnilateralMastectomyLeftPerformed",
                              "type" : "Property"
                           } ]
                        } ]
                     }
                  }, {
                     "localId" : "390",
                     "locator" : "84:88-84:114",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "391",
                        "locator" : "84:95-84:114",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "398",
            "locator" : "86:1-88:107",
            "name" : "Bilateral Mastectomy Diagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "398",
                  "s" : [ {
                     "value" : [ "","define ","\"Bilateral Mastectomy Diagnosis\"",":\n  " ]
                  }, {
                     "r" : "410",
                     "s" : [ {
                        "s" : [ {
                           "r" : "399",
                           "s" : [ {
                              "r" : "402",
                              "s" : [ {
                                 "r" : "402",
                                 "s" : [ {
                                    "value" : [ "[","Condition",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"History of bilateral mastectomy\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","BilateralMastectomyHistory" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "409",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "409",
                           "s" : [ {
                              "r" : "405",
                              "s" : [ {
                                 "r" : "404",
                                 "s" : [ {
                                    "value" : [ "BilateralMastectomyHistory" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "405",
                                 "s" : [ {
                                    "value" : [ "prevalenceInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "409",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "406",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "407",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "410",
               "locator" : "87:3-88:107",
               "type" : "Query",
               "source" : [ {
                  "localId" : "399",
                  "locator" : "87:3-87:75",
                  "alias" : "BilateralMastectomyHistory",
                  "expression" : {
                     "localId" : "402",
                     "locator" : "87:3-87:48",
                     "dataType" : "{http://hl7.org/fhir}Condition",
                     "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                     "codeProperty" : "code",
                     "codeComparator" : "in",
                     "type" : "Retrieve",
                     "codes" : {
                        "localId" : "401",
                        "locator" : "87:15-87:47",
                        "name" : "History of bilateral mastectomy",
                        "preserve" : true,
                        "type" : "ValueSetRef"
                     },
                     "include" : [ ],
                     "codeFilter" : [ ],
                     "dateFilter" : [ ],
                     "otherFilter" : [ ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "409",
                  "locator" : "88:5-88:107",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "408",
                     "locator" : "88:61-88:66",
                     "type" : "Start",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "405",
                        "locator" : "88:11-88:59",
                        "name" : "prevalenceInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "404",
                           "locator" : "88:11-88:36",
                           "name" : "BilateralMastectomyHistory",
                           "type" : "AliasRef"
                        } ]
                     }
                  }, {
                     "localId" : "406",
                     "locator" : "88:81-88:107",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "407",
                        "locator" : "88:88-88:107",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "414",
            "locator" : "90:1-92:109",
            "name" : "Bilateral Mastectomy Procedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "414",
                  "s" : [ {
                     "value" : [ "","define ","\"Bilateral Mastectomy Procedure\"",":\n  " ]
                  }, {
                     "r" : "429",
                     "s" : [ {
                        "s" : [ {
                           "r" : "415",
                           "s" : [ {
                              "r" : "420",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "420",
                                 "s" : [ {
                                    "r" : "418",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "418",
                                       "s" : [ {
                                          "value" : [ "[","Procedure",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Bilateral Mastectomy\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "420",
                                    "s" : [ {
                                       "value" : [ "isProcedurePerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","BilateralMastectomyPerformed" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "428",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "428",
                           "s" : [ {
                              "r" : "424",
                              "s" : [ {
                                 "r" : "423",
                                 "s" : [ {
                                    "r" : "421",
                                    "s" : [ {
                                       "value" : [ "BilateralMastectomyPerformed" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "423",
                                    "s" : [ {
                                       "value" : [ "performed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "424",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "428",
                              "value" : [ " ","ends on or before"," " ]
                           }, {
                              "r" : "425",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "426",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "429",
               "locator" : "91:3-92:109",
               "type" : "Query",
               "source" : [ {
                  "localId" : "415",
                  "locator" : "91:3-91:99",
                  "alias" : "BilateralMastectomyPerformed",
                  "expression" : {
                     "localId" : "420",
                     "locator" : "91:3-91:70",
                     "name" : "isProcedurePerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "418",
                        "locator" : "91:5-91:43",
                        "dataType" : "{http://hl7.org/fhir}Procedure",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "417",
                           "locator" : "91:19-91:40",
                           "name" : "Bilateral Mastectomy",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "428",
                  "locator" : "92:5-92:109",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "427",
                     "locator" : "92:65-92:68",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "424",
                        "locator" : "92:11-92:63",
                        "name" : "toInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "423",
                           "locator" : "92:11-92:48",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "422",
                              "path" : "performed",
                              "scope" : "BilateralMastectomyPerformed",
                              "type" : "Property"
                           } ]
                        } ]
                     }
                  }, {
                     "localId" : "425",
                     "locator" : "92:83-92:109",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "426",
                        "locator" : "92:90-92:109",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "268",
            "locator" : "45:1-58:69",
            "name" : "Denominator Exclusions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "268",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator Exclusions\"",":\n  " ]
                  }, {
                     "r" : "269",
                     "s" : [ {
                        "r" : "270",
                        "s" : [ {
                           "r" : "271",
                           "s" : [ {
                              "r" : "272",
                              "s" : [ {
                                 "r" : "273",
                                 "s" : [ {
                                    "r" : "274",
                                    "s" : [ {
                                       "r" : "276",
                                       "s" : [ {
                                          "r" : "275",
                                          "s" : [ {
                                             "value" : [ "Hospice" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "276",
                                          "s" : [ {
                                             "value" : [ "\"Has Hospice Services\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    or " ]
                                    }, {
                                       "r" : "277",
                                       "s" : [ {
                                          "value" : [ "( " ]
                                       }, {
                                          "r" : "277",
                                          "s" : [ {
                                             "r" : "278",
                                             "s" : [ {
                                                "value" : [ "( " ]
                                             }, {
                                                "r" : "278",
                                                "s" : [ {
                                                   "r" : "279",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "318",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "318",
                                                         "s" : [ {
                                                            "value" : [ "\"Right Mastectomy Diagnosis\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n          or " ]
                                                }, {
                                                   "r" : "319",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "337",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "337",
                                                         "s" : [ {
                                                            "value" : [ "\"Right Mastectomy Procedure\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n      )" ]
                                             } ]
                                          }, {
                                             "value" : [ "\n        and " ]
                                          }, {
                                             "r" : "338",
                                             "s" : [ {
                                                "value" : [ "( " ]
                                             }, {
                                                "r" : "338",
                                                "s" : [ {
                                                   "r" : "339",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "376",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "376",
                                                         "s" : [ {
                                                            "value" : [ "\"Left Mastectomy Diagnosis\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n            or " ]
                                                }, {
                                                   "r" : "377",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "395",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "395",
                                                         "s" : [ {
                                                            "value" : [ "\"Left Mastectomy Procedure\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n        )" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n    )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    or " ]
                                 }, {
                                    "r" : "396",
                                    "s" : [ {
                                       "value" : [ "exists " ]
                                    }, {
                                       "r" : "411",
                                       "s" : [ {
                                          "value" : [ "\"Bilateral Mastectomy Diagnosis\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    or " ]
                              }, {
                                 "r" : "412",
                                 "s" : [ {
                                    "value" : [ "exists " ]
                                 }, {
                                    "r" : "430",
                                    "s" : [ {
                                       "value" : [ "\"Bilateral Mastectomy Procedure\"" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    or " ]
                           }, {
                              "r" : "432",
                              "s" : [ {
                                 "r" : "431",
                                 "s" : [ {
                                    "value" : [ "AIFrailLTCF" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "432",
                                 "s" : [ {
                                    "value" : [ "\"Is Age 66 or Older with Advanced Illness and Frailty\"" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "434",
                           "s" : [ {
                              "r" : "433",
                              "s" : [ {
                                 "value" : [ "AIFrailLTCF" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "434",
                              "s" : [ {
                                 "value" : [ "\"Is Age 66 or Older Living Long Term in a Nursing Home\"" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    or " ]
                     }, {
                        "r" : "436",
                        "s" : [ {
                           "r" : "435",
                           "s" : [ {
                              "value" : [ "PalliativeCare" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "436",
                           "s" : [ {
                              "value" : [ "\"Has Palliative Care in the Measurement Period\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "269",
               "locator" : "46:3-58:69",
               "type" : "Or",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "270",
                  "locator" : "46:3-57:74",
                  "type" : "Or",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "271",
                     "locator" : "46:3-56:73",
                     "type" : "Or",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "272",
                        "locator" : "46:3-55:46",
                        "type" : "Or",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "273",
                           "locator" : "46:3-54:46",
                           "type" : "Or",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "274",
                              "locator" : "46:3-53:5",
                              "type" : "Or",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "276",
                                 "locator" : "46:3-46:32",
                                 "name" : "Has Hospice Services",
                                 "libraryName" : "Hospice",
                                 "type" : "ExpressionRef"
                              }, {
                                 "localId" : "277",
                                 "locator" : "47:8-53:5",
                                 "type" : "And",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "278",
                                    "locator" : "47:10-49:7",
                                    "type" : "Or",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "279",
                                       "locator" : "47:12-47:50",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "318",
                                          "locator" : "47:19-47:50",
                                          "name" : "Right Mastectomy Diagnosis",
                                          "type" : "ExpressionRef"
                                       }
                                    }, {
                                       "localId" : "319",
                                       "locator" : "48:14-48:52",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "337",
                                          "locator" : "48:21-48:52",
                                          "name" : "Right Mastectomy Procedure",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "338",
                                    "locator" : "50:13-52:9",
                                    "type" : "Or",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "339",
                                       "locator" : "50:15-50:52",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "376",
                                          "locator" : "50:22-50:52",
                                          "name" : "Left Mastectomy Diagnosis",
                                          "type" : "ExpressionRef"
                                       }
                                    }, {
                                       "localId" : "377",
                                       "locator" : "51:16-51:53",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "395",
                                          "locator" : "51:23-51:53",
                                          "name" : "Left Mastectomy Procedure",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "localId" : "396",
                              "locator" : "54:8-54:46",
                              "type" : "Exists",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "411",
                                 "locator" : "54:15-54:46",
                                 "name" : "Bilateral Mastectomy Diagnosis",
                                 "type" : "ExpressionRef"
                              }
                           } ]
                        }, {
                           "localId" : "412",
                           "locator" : "55:8-55:46",
                           "type" : "Exists",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "430",
                              "locator" : "55:15-55:46",
                              "name" : "Bilateral Mastectomy Procedure",
                              "type" : "ExpressionRef"
                           }
                        } ]
                     }, {
                        "localId" : "432",
                        "locator" : "56:8-56:73",
                        "name" : "Is Age 66 or Older with Advanced Illness and Frailty",
                        "libraryName" : "AIFrailLTCF",
                        "type" : "ExpressionRef"
                     } ]
                  }, {
                     "localId" : "434",
                     "locator" : "57:8-57:74",
                     "name" : "Is Age 66 or Older Living Long Term in a Nursing Home",
                     "libraryName" : "AIFrailLTCF",
                     "type" : "ExpressionRef"
                  } ]
               }, {
                  "localId" : "436",
                  "locator" : "58:8-58:69",
                  "name" : "Has Palliative Care in the Measurement Period",
                  "libraryName" : "PalliativeCare",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "451",
            "locator" : "99:1-100:79",
            "name" : "October 1 Two Years Prior to the Measurement Period",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "451",
                  "s" : [ {
                     "value" : [ "","define ","\"October 1 Two Years Prior to the Measurement Period\"",":\n  " ]
                  }, {
                     "r" : "468",
                     "s" : [ {
                        "value" : [ "DateTime","(" ]
                     }, {
                        "r" : "452",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "452",
                           "s" : [ {
                              "r" : "453",
                              "s" : [ {
                                 "value" : [ "year from " ]
                              }, {
                                 "r" : "454",
                                 "s" : [ {
                                    "value" : [ "start of " ]
                                 }, {
                                    "r" : "455",
                                    "s" : [ {
                                       "value" : [ "\"Measurement Period\"" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "r" : "456",
                              "value" : [ " - ","2" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     }, {
                        "r" : "457",
                        "value" : [ ", ","10",", ","1",", ","0",", ","0",", ","0",", ","0",", ","0",")" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "468",
               "locator" : "100:3-100:79",
               "type" : "DateTime",
               "signature" : [ ],
               "year" : {
                  "localId" : "452",
                  "locator" : "100:12-100:56",
                  "type" : "Subtract",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "453",
                     "locator" : "100:13-100:51",
                     "precision" : "Year",
                     "type" : "DateTimeComponentFrom",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "454",
                        "locator" : "100:23-100:51",
                        "type" : "Start",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "455",
                           "locator" : "100:32-100:51",
                           "name" : "Measurement Period",
                           "type" : "ParameterRef"
                        }
                     }
                  }, {
                     "localId" : "456",
                     "locator" : "100:55",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2",
                     "type" : "Literal"
                  } ]
               },
               "month" : {
                  "localId" : "457",
                  "locator" : "100:59-100:60",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "10",
                  "type" : "Literal"
               },
               "day" : {
                  "localId" : "458",
                  "locator" : "100:63",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "1",
                  "type" : "Literal"
               },
               "hour" : {
                  "localId" : "459",
                  "locator" : "100:66",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "minute" : {
                  "localId" : "460",
                  "locator" : "100:69",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "second" : {
                  "localId" : "461",
                  "locator" : "100:72",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "millisecond" : {
                  "localId" : "462",
                  "locator" : "100:75",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "timezoneOffset" : {
                  "localId" : "470",
                  "type" : "ToDecimal",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "463",
                     "locator" : "100:78",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               }
            }
         }, {
            "localId" : "438",
            "locator" : "94:1-97:3",
            "name" : "Numerator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "438",
                  "s" : [ {
                     "value" : [ "","define ","\"Numerator\"",":\n  " ]
                  }, {
                     "r" : "439",
                     "s" : [ {
                        "value" : [ "exists " ]
                     }, {
                        "r" : "477",
                        "s" : [ {
                           "value" : [ "( " ]
                        }, {
                           "r" : "477",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "440",
                                 "s" : [ {
                                    "r" : "445",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "445",
                                       "s" : [ {
                                          "r" : "443",
                                          "s" : [ {
                                             "value" : [ "( " ]
                                          }, {
                                             "r" : "443",
                                             "s" : [ {
                                                "value" : [ "[","Observation",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Mammography\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          }, {
                                             "value" : [ " )" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "445",
                                          "s" : [ {
                                             "value" : [ "isDiagnosticStudyPerformed"," ( )" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ " ","Mammogram" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "476",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "476",
                                 "s" : [ {
                                    "r" : "449",
                                    "s" : [ {
                                       "r" : "448",
                                       "s" : [ {
                                          "r" : "446",
                                          "s" : [ {
                                             "value" : [ "Mammogram" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "448",
                                          "s" : [ {
                                             "value" : [ "effective" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "449",
                                       "s" : [ {
                                          "value" : [ "toInterval"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "476",
                                    "value" : [ " ","ends during day of"," " ]
                                 }, {
                                    "r" : "474",
                                    "s" : [ {
                                       "value" : [ "Interval[" ]
                                    }, {
                                       "r" : "471",
                                       "s" : [ {
                                          "value" : [ "\"October 1 Two Years Prior to the Measurement Period\"" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "472",
                                       "s" : [ {
                                          "value" : [ "end of " ]
                                       }, {
                                          "r" : "473",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "439",
               "locator" : "95:3-97:3",
               "type" : "Exists",
               "signature" : [ ],
               "operand" : {
                  "localId" : "477",
                  "locator" : "95:10-97:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "440",
                     "locator" : "95:12-95:88",
                     "alias" : "Mammogram",
                     "expression" : {
                        "localId" : "445",
                        "locator" : "95:12-95:78",
                        "name" : "isDiagnosticStudyPerformed",
                        "libraryName" : "Status",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "443",
                           "locator" : "95:14-95:45",
                           "dataType" : "{http://hl7.org/fhir}Observation",
                           "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation",
                           "codeProperty" : "code",
                           "codeComparator" : "in",
                           "type" : "Retrieve",
                           "codes" : {
                              "localId" : "442",
                              "locator" : "95:30-95:42",
                              "name" : "Mammography",
                              "preserve" : true,
                              "type" : "ValueSetRef"
                           },
                           "include" : [ ],
                           "codeFilter" : [ ],
                           "dateFilter" : [ ],
                           "otherFilter" : [ ]
                        } ]
                     }
                  } ],
                  "let" : [ ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "476",
                     "locator" : "96:7-96:158",
                     "precision" : "Day",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "475",
                        "locator" : "96:48-96:51",
                        "type" : "End",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "449",
                           "locator" : "96:13-96:46",
                           "name" : "toInterval",
                           "libraryName" : "QICoreCommon",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "448",
                              "locator" : "96:13-96:31",
                              "name" : "ToValue",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "447",
                                 "path" : "effective",
                                 "scope" : "Mammogram",
                                 "type" : "Property"
                              } ]
                           } ]
                        }
                     }, {
                        "localId" : "474",
                        "locator" : "96:67-96:158",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "471",
                           "locator" : "96:76-96:128",
                           "name" : "October 1 Two Years Prior to the Measurement Period",
                           "type" : "ExpressionRef"
                        },
                        "high" : {
                           "localId" : "472",
                           "locator" : "96:131-96:157",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "473",
                              "locator" : "96:138-96:157",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "479",
            "locator" : "102:1-103:21",
            "name" : "SDE Ethnicity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "479",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Ethnicity\"",":\n  " ]
                  }, {
                     "r" : "481",
                     "s" : [ {
                        "r" : "480",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "481",
                        "s" : [ {
                           "value" : [ "\"SDE Ethnicity\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "481",
               "locator" : "103:3-103:21",
               "name" : "SDE Ethnicity",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "483",
            "locator" : "105:1-106:17",
            "name" : "SDE Payer",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "483",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Payer\"",":\n  " ]
                  }, {
                     "r" : "485",
                     "s" : [ {
                        "r" : "484",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "485",
                        "s" : [ {
                           "value" : [ "\"SDE Payer\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "485",
               "locator" : "106:3-106:17",
               "name" : "SDE Payer",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "487",
            "locator" : "108:1-109:16",
            "name" : "SDE Race",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "487",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Race\"",":\n  " ]
                  }, {
                     "r" : "489",
                     "s" : [ {
                        "r" : "488",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "489",
                        "s" : [ {
                           "value" : [ "\"SDE Race\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "489",
               "locator" : "109:3-109:16",
               "name" : "SDE Race",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "491",
            "locator" : "111:1-112:15",
            "name" : "SDE Sex",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "491",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Sex\"",":\n  " ]
                  }, {
                     "r" : "493",
                     "s" : [ {
                        "r" : "492",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "493",
                        "s" : [ {
                           "value" : [ "\"SDE Sex\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "493",
               "locator" : "112:3-112:15",
               "name" : "SDE Sex",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         } ]
      }
   }
}" + } + ] + }, + "request": { + "method": "PUT", + "url": "Measure/BreastCancerScreeningFHIR" + } + } + ] +} diff --git a/cqf-fhir-utility/src/test/resources/org/opencds/cqf/fhir/utility/visitor/r5/Bundle-ecqm-qicore-2024-simplified.json b/cqf-fhir-utility/src/test/resources/org/opencds/cqf/fhir/utility/visitor/r5/Bundle-ecqm-qicore-2024-simplified.json new file mode 100644 index 000000000..6d2598a14 --- /dev/null +++ b/cqf-fhir-utility/src/test/resources/org/opencds/cqf/fhir/utility/visitor/r5/Bundle-ecqm-qicore-2024-simplified.json @@ -0,0 +1,5078 @@ +{ + "resourceType": "Bundle", + "id": "ecqm-content-qicore-2024-subset-simplified-bundle", + "type": "transaction", + "timestamp": "2022-10-21T15:18:28.504-04:00", + "entry": [ + { + "fullUrl": "http://hl7.org/fhir/us/cqfmeasures/Library/ecqm-update-2024-05-02|1.0.0", + "resource": { + "resourceType": "Library", + "id": "ecqm-update-2024-05-02", + "meta": { + "profile": [ + "http://hl7.org/fhir/uv/crmi/StructureDefinition/crmi-manifestlibrary" + ] + }, + "contained": [ + { + "resourceType": "Parameters", + "id": "exp-params", + "parameter": [ + { + "name": "system-version", + "valueUri": "http://snomed.info/sct|http://snomed.info/sct/731000124108/version/20230901" + }, + { + "name": "system-version", + "valueUri": "http://loinc.org|2.76" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/v3-ActCode|9.0.0" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender|3.0.0" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/CD2|2.0.1" + }, + { + "name": "system-version", + "valueUri": "urn:oid:2.16.840.1.113883.6.238|1.2" + }, + { + "name": "system-version", + "valueUri": "http://www.ama-assn.org/go/cpt|3.0.1" + }, + { + "name": "system-version", + "valueUri": "http://hl7.org/fhir/sid/cvx|4.0.0" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/HCPCS-all-codes|3.0.0" + }, + { + "name": "system-version", + "valueUri": "http://www.cms.gov/Medicare/Coding/HCPCSReleaseCodeSets|1.0.2" + }, + { + "name": "system-version", + "valueUri": "http://hl7.org/fhir/sid/icd-10-cm|2.0.1" + }, + { + "name": "system-version", + "valueUri": "http://www.cms.gov/Medicare/Coding/ICD10|2.0.1" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/icd9cm|2.0.1" + }, + { + "name": "system-version", + "valueUri": "http://terminology.hl7.org/CodeSystem/v2-0895|2.2.0" + }, + { + "name": "system-version", + "valueUri": "http://www.nlm.nih.gov/research/umls/rxnorm|3.0.1" + }, + { + "name": "system-version", + "valueUri": "https://nahdo.org/sopt|1.0.1" + } + ] + } + ], + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expansionParameters", + "valueReference": { + "reference": "#exp-params" + } + } + ], + "url": "http://hl7.org/fhir/us/cqfmeasures/Library/ecqm-update-2024-05-02", + "identifier": [ + { + "use": "official", + "system": "http://example.org/fhir/cqi/ecqm/Library/Identifier", + "value": "eCQM Update 2024-05-02" + } + ], + "version": "1.0.0", + "name": "ECQMUpdate20240502", + "title": "eCQM Update 2024-05-02", + "status": "draft", + "experimental": true, + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "asset-collection" + } + ] + }, + "date": "2024-04-23", + "publisher": "Clinical Quality Information WG", + "contact": [ + { + "telecom": [ + { + "system": "url", + "value": "http://www.hl7.org/Special/committees/cqi" + } + ] + } + ], + "description": "This library is an example final draft of a version manifest (also referred to as an expansion profile) that specifies expansion rules for a set of value sets used for an example set of EP/EC measures.", + "useContext": [ + { + "code": { + "system": "http://terminology.hl7.org/CodeSystem/usage-context-type", + "code": "program" + }, + "valueCodeableConcept": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/quality-programs", + "code": "ep-ec", + "display": "EP/EC" + } + ] + } + }, + { + "code": { + "system": "http://terminology.hl7.org/CodeSystem/usage-context-type", + "code": "program" + }, + "valueCodeableConcept": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/quality-programs", + "code": "eh-cah", + "display": "EH/CAH" + } + ] + } + } + ], + "jurisdiction": [ + { + "coding": [ + { + "system": "urn:iso:std:iso:3166", + "code": "US" + } + ] + } + ], + "purpose": "This library is defined to illustrate a Version Manifest in final draft status, as it would look at the end of an eCQM Annual Update cycle, approved on April 23rd, 2024. The latest available version of code systems used at that time is specified to provide stability for value set expansion during the testing and implementation phase. Terminology.HL7.org, in particular, was version 5.5.0 at the time, and FHIR code system versions are chosen from that release.", + "approvalDate": "2024-04-23", + "lastReviewDate": "2024-04-23", + "relatedArtifact": [ + { + "type": "composed-of", + "display": "Measure Cervical Cancer ScreeningFHIR, 0.0.001", + "resource": "https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR|0.0.001" + }, + { + "type": "composed-of", + "display": "Measure Breast Cancer ScreeningFHIR, 0.0.001", + "resource": "https://madie.cms.gov/Measure/BreastCancerScreeningFHIR|0.0.001" + } + ] + }, + "request": { + "method": "PUT", + "url": "Library/ecqm-update-2024-05-02" + } + }, + { + "fullUrl": "https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Measure", + "id": "CervicalCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/publishable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/executable-measure-cqfm" + ] + }, + "contained": [ + { + "resourceType": "Library", + "id": "effective-data-requirements", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/observation-category", + "code": "laboratory", + "display": "laboratory" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428361000124107", + "display": "Discharge to home for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428371000124100", + "display": "Discharge to healthcare facility for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/observation-category", + "code": "survey", + "display": "survey" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "373066001", + "display": "Yes (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Cervical Cytology Within 3 Years" + }, + { + "url": "statement", + "valueString": "define \"Cervical Cytology Within 3 Years\":\n ( ( [Observation: \"Pap Test\"] ).isLaboratoryTestPerformed ( ) ) CervicalCytology\n where CervicalCytology.effective.latest ( ) during day of Interval[start of \"Measurement Period\" - 2 years, end of \"Measurement Period\"]\n and CervicalCytology.value is not null" + }, + { + "url": "displaySequence", + "valueInteger": 0 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "HPV Test Within 5 Years for Women Age 30 and Older" + }, + { + "url": "statement", + "valueString": "define \"HPV Test Within 5 Years for Women Age 30 and Older\":\n ( ( [Observation: \"HPV Test\"] ).isLaboratoryTestPerformed ( ) ) HPVTest\n where AgeInYearsAt(date from HPVTest.effective.latest()) >= 30\n and HPVTest.effective.latest ( ) during day of Interval[start of \"Measurement Period\" - 4 years, end of \"Measurement Period\"]\n and HPVTest.value is not null" + }, + { + "url": "displaySequence", + "valueInteger": 1 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Numerator" + }, + { + "url": "statement", + "valueString": "define \"Numerator\":\n exists \"Cervical Cytology Within 3 Years\"\n or exists \"HPV Test Within 5 Years for Women Age 30 and Older\"" + }, + { + "url": "displaySequence", + "valueInteger": 2 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Qualifying Encounters" + }, + { + "url": "statement", + "valueString": "define \"Qualifying Encounters\":\n ( ( [\"Encounter\": \"Office Visit\"]\n union [Encounter: \"Preventive Care Services Established Office Visit, 18 and Up\"]\n union [Encounter: \"Preventive Care Services Initial Office Visit, 18 and Up\"]\n union [Encounter: \"Home Healthcare Services\"]\n union [Encounter: \"Telephone Visits\"]\n union [Encounter: \"Virtual Encounter\"]\n ).isEncounterPerformed ( ) ) ValidEncounters\n where ValidEncounters.period.toInterval ( ) during day of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 3 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Initial Population" + }, + { + "url": "statement", + "valueString": "define \"Initial Population\":\n AgeInYearsAt(date from \n end of \"Measurement Period\"\n ) in Interval[24, 64]\n and Patient.gender = 'female'\n and exists \"Qualifying Encounters\"" + }, + { + "url": "displaySequence", + "valueInteger": 4 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator" + }, + { + "url": "statement", + "valueString": "define \"Denominator\":\n \"Initial Population\"" + }, + { + "url": "displaySequence", + "valueInteger": 5 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Hospice" + }, + { + "url": "name", + "valueString": "Has Hospice Services" + }, + { + "url": "statement", + "valueString": "define \"Has Hospice Services\":\n exists ((([Encounter: \"Encounter Inpatient\"]).isEncounterPerformed()) InpatientEncounter\n where (InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to home for hospice care (procedure)\"\n or InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to healthcare facility for hospice care (procedure)\"\n )\n and InpatientEncounter.period.toInterval() ends during day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Hospice Encounter\"]).isEncounterPerformed()) HospiceEncounter\n where HospiceEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Observation: \"Hospice care [Minimum Data Set]\"]).isAssessmentPerformed()) HospiceAssessment\n where HospiceAssessment.value ~ \"Yes (qualifier value)\"\n and HospiceAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([ServiceRequest: \"Hospice Care Ambulatory\"]).isInterventionOrder()) HospiceOrder\n where HospiceOrder.authoredOn.toInterval() during day of \"Measurement Period\"\n // and HospiceOrder.doNotPerform is not true\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-447\n )\n or exists ((([Procedure: \"Hospice Care Ambulatory\"]).isInterventionPerformed()) HospicePerformed\n where HospicePerformed.performed.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists (([Condition: \"Hospice Diagnosis\"]) HospiceCareDiagnosis\n where HospiceCareDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 6 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Absence of Cervix" + }, + { + "url": "statement", + "valueString": "define \"Absence of Cervix\":\n ( ( ( [Procedure: \"Hysterectomy with No Residual Cervix\"] ).isProcedurePerformed ( ) ) NoCervixProcedure\n where NoCervixProcedure.performed.toInterval ( ) ends on or before end of \"Measurement Period\"\n )\n union ( [Condition: \"Congenital or Acquired Absence of Cervix\"] NoCervixDiagnosis\n where NoCervixDiagnosis.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 7 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "PalliativeCare" + }, + { + "url": "name", + "valueString": "Has Palliative Care in the Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Palliative Care in the Measurement Period\":\n exists ((([Observation: \"Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)\"]).isAssessmentPerformed()) PalliativeAssessment\n where PalliativeAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ([Condition: \"Palliative Care Diagnosis\"] PalliativeDiagnosis\n where PalliativeDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Palliative Care Encounter\"]).isEncounterPerformed()) PalliativeEncounter\n where PalliativeEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Procedure: \"Palliative Care Intervention\"]).isInterventionPerformed()) PalliativeIntervention\n where PalliativeIntervention.performed.toInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 8 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CervicalCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator Exclusions" + }, + { + "url": "statement", + "valueString": "define \"Denominator Exclusions\":\n Hospice.\"Has Hospice Services\"\n or exists \"Absence of Cervix\"\n or PalliativeCare.\"Has Palliative Care in the Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 9 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isLaboratoryTestPerformed" + }, + { + "url": "statement", + "valueString": "//Laboratory Test, Performed\ndefine fluent function isLaboratoryTestPerformed(Obs List):\n Obs O\n where O.status in { 'final', 'amended', 'corrected' }\n and exists ( O.category ObservationCategory\n where ( ObservationCategory ) ~ \"laboratory\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 10 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "FHIRHelpers" + }, + { + "url": "name", + "valueString": "ToConcept" + }, + { + "url": "statement", + "valueString": "/*\n@description: Converts the given FHIR [CodeableConcept](https://hl7.org/fhir/datatypes.html#CodeableConcept) value to a CQL Concept.\n*/\ndefine function ToConcept(concept FHIR.CodeableConcept):\n if concept is null then\n null\n else\n System.Concept {\n codes: concept.coding C return ToCode(C),\n display: concept.text.value\n }" + }, + { + "url": "displaySequence", + "valueInteger": 11 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "latest" + }, + { + "url": "statement", + "valueString": "/*\n@description: Given an interval, returns the ending point if the interval has an ending boundary specified,\notherwise, returns the starting point\n*/\ndefine fluent function latest(choice Choice, Interval> ):\n (choice.toInterval()) period\n return\n if (period.\"hasEnd\"()) then end of period\n else start of period" + }, + { + "url": "displaySequence", + "valueInteger": 12 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isEncounterPerformed" + }, + { + "url": "statement", + "valueString": "//Encounter, Performed\n//General usage unless required otherwise by measure intent (e.g., follow-up encounters)\ndefine fluent function isEncounterPerformed(Enc List):\n Enc E\n where E.status in {'finished', 'arrived', 'triaged', 'in-progress', 'onleave'}" + }, + { + "url": "displaySequence", + "valueInteger": 13 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "toInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval\n@comment: Normalizes a choice type of DateTime, Quanitty, Interval, or Interval types\nto an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible\nrepresentations for timing-valued elements in QICore, allowing this function to be used across any resource.\nThe input can be provided as a DateTime, Quantity, Interval or Interval.\nThe intent of this function is to provide a clear and concise mechanism to treat single\nelements that have multiple possible representations as intervals so that logic doesn't have to account\nfor the variability. More complex calculations (such as medication request period or dispense period\ncalculation) need specific guidance and consideration. That guidance may make use of this function, but\nthe focus of this function is on single element calculations where the semantics are unambiguous.\nIf the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.\nIf the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,\nand the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.\nIf the input is a DateTime Interval, the result is the input.\nIf the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result\nis a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending\nimmediately before one year later than the date the patient turned the age given as the end of the quantity interval.\nIf the input is a Timing, an error will be thrown indicating that Timing calculations are not implemented. Any other input will reslt in a null DateTime Interval\n*/\ndefine fluent function toInterval(choice Choice, Interval, Timing>):\n case\n\t when choice is DateTime then\n \tInterval[choice as DateTime, choice as DateTime]\n\t\twhen choice is Interval then\n \t\tchoice as Interval\n\t\twhen choice is Quantity then\n\t\t Interval[Patient.birthDate + (choice as Quantity),\n\t\t\t Patient.birthDate + (choice as Quantity) + 1 year)\n\t\twhen choice is Interval then\n\t\t Interval[Patient.birthDate + (choice.low as Quantity),\n\t\t\t Patient.birthDate + (choice.high as Quantity) + 1 year)\n\t\twhen choice is Timing then\n Message(null, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a Timing value is not supported') as Interval\n\t\telse\n\t\t\tnull as Interval\n\tend" + }, + { + "url": "displaySequence", + "valueInteger": 14 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isAssessmentPerformed" + }, + { + "url": "statement", + "valueString": "//This library contains functions that are based on QDM 5.6 to QICore 4.1.1 March 2023 (https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns---QICore-v4.1.1). The functions may appear similar to some QICoreCommon functions but different in that they have constraints that are relevant for measures authored by NCQA.\n\n//Assessment, Performed\ndefine fluent function isAssessmentPerformed(Obs List):\n Obs O\n where O.status in { 'final', 'amended', 'corrected' }\n and exists ( O.category ObservationCategory\n where ( ObservationCategory ) ~ \"survey\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 15 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionOrder" + }, + { + "url": "statement", + "valueString": "//Intervention, Order: active and completed only \ndefine fluent function isInterventionOrder(ServiceRequest List):\n ServiceRequest S\n where S.status in { 'active', 'completed' }\n and S.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 16 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionPerformed" + }, + { + "url": "statement", + "valueString": "//Intervention, Performed\ndefine fluent function isInterventionPerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 17 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "prevalenceInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Returns an interval representing the normalized prevalence period of a given Condition.\n@comment: Uses the ToInterval and ToAbatementInterval functions to determine the widest potential interval from\nonset to abatement as specified in the given Condition. If the condition is active, or has an abatement date the resulting \ninterval will have a closed ending boundary. Otherwise, the resulting interval will have an open ending boundary.\n*/\ndefine fluent function prevalenceInterval(condition Condition):\nif condition.clinicalStatus ~ \"active\"\n or condition.clinicalStatus ~ \"recurrence\"\n or condition.clinicalStatus ~ \"relapse\" then\n Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()]\nelse\n (end of condition.abatementInterval()) abatementDate\n return if abatementDate is null then\n Interval[start of condition.onset.toInterval(), abatementDate)\n else\n Interval[start of condition.onset.toInterval(), abatementDate]" + }, + { + "url": "displaySequence", + "valueInteger": 18 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isProcedurePerformed" + }, + { + "url": "statement", + "valueString": "//Procedure, Performed\ndefine fluent function isProcedurePerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 19 + } + ] + } + ], + "name": "EffectiveDataRequirements", + "status": "active", + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "module-definition" + } + ] + }, + "relatedArtifact": [ + { + "type": "depends-on", + "display": "Library Status", + "resource": "Library/Status|1.8.000" + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "Library/FHIRHelpers|4.4.000" + }, + { + "type": "depends-on", + "display": "Library QICoreCommon", + "resource": "Library/QICoreCommon|2.1.000" + }, + { + "type": "depends-on", + "display": "Library Hospice", + "resource": "Library/Hospice|6.12.000" + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": "Library/PalliativeCare|1.11.000" + }, + { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": "http://terminology.hl7.org/CodeSystem/observation-category" + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, + { + "type": "depends-on", + "display": "Value set Pap Test", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" + }, + { + "type": "depends-on", + "display": "Value set HPV Test", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" + }, + { + "type": "depends-on", + "display": "Value set Office Visit", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Established Office Visit, 18 and Up", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Initial Office Visit, 18 and Up", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + }, + { + "type": "depends-on", + "display": "Value set Home Healthcare Services", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + }, + { + "type": "depends-on", + "display": "Value set Telephone Visits", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + }, + { + "type": "depends-on", + "display": "Value set Virtual Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + }, + { + "type": "depends-on", + "display": "Value set Encounter Inpatient", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + }, + { + "type": "depends-on", + "display": "Value set Hospice Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + }, + { + "type": "depends-on", + "display": "Value set Hospice Care Ambulatory", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + }, + { + "type": "depends-on", + "display": "Value set Hospice Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + }, + { + "type": "depends-on", + "display": "Value set Hysterectomy with No Residual Cervix", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + }, + { + "type": "depends-on", + "display": "Value set Congenital or Acquired Absence of Cervix", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Intervention", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + } + ], + "dataRequirement": [ + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ] + }, + { + "path": "value" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ] + } + ] + }, + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + ] + } + ] + } + ], + "extension": [ + { + "id": "effective-data-requirements", + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-effectiveDataRequirements", + "valueReference": { + "reference": "#effective-data-requirements" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + }, + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlOptions", + "valueReference": { + "reference": "Measure/cql-options-test" + } + }, + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expansionParameters", + "valueReference": { + "reference": "#exp-params-test-absent" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-inputParameters", + "valueReference": { + "reference": "Library/input-parameters-test" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-component", + "valueRelatedArtifact": { + "resource": "Library/cqfm-component-test", + "type": "composed-of" + } + } + ], + "url": "https://madie.cms.gov/Measure/CervicalCancerScreeningFHIR", + "identifier": [ + { + "use": "usual", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "short-name" + } + ] + }, + "system": "https://madie.cms.gov/measure/shortName", + "value": "CMS124FHIR" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-independent" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:3be5df74-24e1-46ed-b899-6e98b9e3760b" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-specific" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:d66e7255-e320-4d80-b28a-091f041ea7e0" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "publisher" + } + ] + }, + "system": "https://madie.cms.gov/measure/cmsId", + "value": "124FHIR", + "assigner": { + "display": "CMS" + } + } + ], + "version": "0.0.001", + "name": "CervicalCancerScreeningFHIR", + "title": "Cervical Cancer ScreeningFHIR", + "status": "active", + "experimental": false, + "date": "2024-07-09T14:53:56+00:00", + "publisher": "National Committee for Quality Assurance", + "contact": [ + { + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "description": "Percentage of women 21-64 years of age who were screened for cervical cancer using either of the following criteria: - Women age 21-64 who had cervical cytology performed within the last 3 years - Women age 30-64 who had cervical human papillomavirus (HPV) testing performed within the last 5 years", + "purpose": "UNKNOWN", + "usage": "To ensure the measure is only looking for a cervical cytology test only after a woman turns 21 years of age, the youngest age in the initial population is 23. Please note the measure may include screenings performed outside the age range of patients referenced in the initial population. Screenings that occur prior to the measurement period are valid to meet measure criteria. Evidence of hrHPV testing within the last 5 years also captures patients who had cotesting; therefore additional methods to identify cotesting are not necessary. This eCQM is a patient-based measure. This FHIR-based measure has been derived from the QDM-based measure: CMS124v13. Please refer to the HL7 QI-Core Implementation Guide (https://hl7.org/fhir/us/qicore/STU4.1.1/) for more information on QI-Core and mapping recommendations from QDM to QI-Core 4.1.1 (https://hl7.org/fhir/us/qicore/STU4.1.1/qdm-to-qicore.html).", + "copyright": "This Physician Performance Measure (Measure) and related data specifications are owned and were developed by the National Committee for Quality Assurance (NCQA). NCQA is not responsible for any use of the Measure. NCQA makes no representations, warranties, or endorsement about the quality of any organization or physician that uses or reports performance measures and NCQA has no liability to anyone who relies on such measures or specifications. NCQA holds a copyright in the Measure. The Measure can be reproduced and distributed, without modification, for noncommercial purposes (e.g., use by healthcare providers in connection with their practices) without obtaining approval from NCQA. Commercial use is defined as the sale, licensing, or distribution of the Measure for commercial gain, or incorporation of the Measure into a product or service that is sold, licensed or distributed for commercial gain. All commercial uses or requests for modification must be approved by NCQA and are subject to a license at the discretion of NCQA. (C) 2012-2021 National Committee for Quality Assurance. All Rights Reserved. Limited proprietary coding is contained in the Measure specifications for user convenience. Users of proprietary code sets should obtain all necessary licenses from the owners of the code sets. NCQA disclaims all liability for use or accuracy of any third party codes contained in the specifications. CPT(R) contained in the Measure specifications is copyright 2004-2021 American Medical Association. LOINC(R) copyright 2004-2021 Regenstrief Institute, Inc. This material contains SNOMED Clinical Terms(R) (SNOMED CT[R]) copyright 2004-2021 International Health Terminology Standards Development Organisation. ICD-10 copyright 2021 World Health Organization. All Rights Reserved.", + "effectivePeriod": { + "start": "2025-01-01", + "end": "2025-12-31" + }, + "author": [ + { + "name": "National Committee for Quality Assurance", + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "library": [ + "https://madie.cms.gov/Library/CervicalCancerScreeningFHIR" + ], + "supplementalData": [ + { + "criteria": { + "reference": "Library/supplemental-criteria-reference-test" + } + } + ], + "disclaimer": "The performance Measure is not a clinical guideline and does not establish a standard of medical care, and has not been tested for all potential applications. THE MEASURE AND SPECIFICATIONS ARE PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. Due to technical limitations, registered trademarks are indicated by (R) or [R] and unregistered trademarks are indicated by (TM) or [TM].", + "rationale": "All women are at risk for cervical cancer. In 2020, an estimated 13,800 women were diagnosed with cervical cancer in the U.S., resulting in an estimated 4,290 deaths (National Cancer Institute, 2020). Screening can identify precancerous lesions and can detect invasive cancer early, when treatment is more likely to be successful (American Cancer Society, 2020).", + "clinicalRecommendationStatement": "US Preventive Services Task Force (USPSTF) (2018) \"The USPSTF recommends screening for cervical cancer every 3 years with cervical cytology alone in women aged 21 to 29 years. For women aged 30 to 65 years, the USPSTF recommends screening every 3 years with cervical cytology alone, every 5 years with high-risk human papillomavirus (hrHPV) testing alone, or every 5 years with hrHPV testing in combination with cytology (cotesting) (A recommendation)\" \"The USPSTF recommends against screening for cervical cancer in women older than 65 years who have had adequate prior screening and are not otherwise at high risk for cervical cancer. (D recommendation)\" \"The USPSTF recommends against screening for cervical cancer in women younger than 21 years. (D recommendation)\" \"The USPSTF recommends against screening for cervical cancer in women who have had a hysterectomy with removal of the cervix and do not have a history of a high-grade precancerous lesion (ie, cervical intraepithelial neoplasia [CIN] grade 2 or 3) or cervical cancer. (D recommendation)\"", + "group": [ + { + "id": "64d29f68f9c3ae6981ef507d", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-scoring", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-scoring", + "code": "proportion", + "display": "Proportion" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-populationBasis", + "valueCode": "boolean" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-type", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-type", + "code": "process", + "display": "Process" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-rateAggregation", + "valueCode": "None" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-improvementNotation", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-improvement-notation", + "code": "decrease", + "display": "increase" + } + ] + } + } + ], + "population": [ + { + "id": "0CB398EC-F7C3-4882-98FF-D9E0E3E62B4F", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "initial-population", + "display": "Initial Population" + } + ] + }, + "description": "Women 24-64 years of age by the end of the measurement period with a visit during the measurement period", + "criteria": { + "language": "text/cql-identifier", + "expression": "Initial Population" + } + }, + { + "id": "C02AA51E-4436-4034-A67F-DB42C22EB337", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator", + "display": "Denominator" + } + ] + }, + "description": "Equals Initial Population", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator" + } + }, + { + "id": "2EF6ABDF-E416-44B8-928B-DCC7D7C55860", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator-exclusion", + "display": "Denominator Exclusion" + } + ] + }, + "description": "Exclude patients who are in hospice care for any part of the measurement period. Women who had a hysterectomy with no residual cervix or a congenital absence of cervix. Exclude patients receiving palliative care for any part of the measurement period.", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator Exclusions" + } + }, + { + "id": "56088E3D-0DEE-43D2-9866-1F38ACB030CB", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "numerator", + "display": "Numerator" + } + ] + }, + "description": "Women with one or more screenings for cervical cancer. Appropriate screenings are defined by any one of the following criteria: - Cervical cytology performed during the measurement period or the two years prior to the measurement period for women who are at least 21 years old at the time of the test. - Cervical human papillomavirus (HPV) testing performed during the measurement period or the four years prior to the measurement period for women who are 30 years or older at the time of the test.", + "criteria": { + "language": "text/cql-identifier", + "expression": "Numerator" + } + }, + { + "criteria": { "reference": "Library/population-criteria-test" } + } + ], + "stratifier": [ + { + "criteria": { "reference": "Library/stratifier-criteria-test" } + }, + { + "component": { + "criteria": { + "reference": "Library/stratifier-component-criteria-test" + } + } + } + ] + } + ] + }, + "request": { + "method": "PUT", + "url": "Measure/CervicalCancerScreeningFHIR" + } + }, + { + "fullUrl": "https://madie.cms.gov/Library/CervicalCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Library", + "id": "CervicalCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-library-cqfm" + ] + }, + "language": "en", + "contained": [ + { + "resourceType": "Parameters", + "id": "options", + "parameter": [ + { + "name": "translatorVersion", + "valueString": "3.10.0" + }, + { + "name": "option", + "valueString": "EnableAnnotations" + }, + { + "name": "option", + "valueString": "EnableLocators" + }, + { + "name": "option", + "valueString": "DisableListDemotion" + }, + { + "name": "option", + "valueString": "DisableListPromotion" + }, + { + "name": "format", + "valueString": "XML" + }, + { + "name": "format", + "valueString": "JSON" + }, + { + "name": "analyzeDataRequirements", + "valueBoolean": true + }, + { + "name": "collapseDataRequirements", + "valueBoolean": true + }, + { + "name": "compatibilityLevel", + "valueString": "1.5" + }, + { + "name": "enableCqlOnly", + "valueBoolean": false + }, + { + "name": "errorLevel", + "valueString": "Info" + }, + { + "name": "signatureLevel", + "valueString": "None" + }, + { + "name": "validateUnits", + "valueBoolean": true + }, + { + "name": "verifyOnly", + "valueBoolean": false + } + ] + } + ], + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlOptions", + "valueReference": { + "reference": "#options" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } + ], + "url": "https://madie.cms.gov/Library/CervicalCancerScreeningFHIR", + "identifier": [ + { + "use": "official", + "system": "https://madie.cms.gov/login", + "value": "CervicalCancerScreeningFHIR" + } + ], + "version": "0.0.001", + "name": "CervicalCancerScreeningFHIR", + "title": "CervicalCancerScreeningFHIR", + "status": "active", + "experimental": false, + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } + ] + }, + "date": "2024-05-16T13:50:20+00:00", + "description": "CervicalCancerScreeningFHIR", + "relatedArtifact": [ + { + "type": "depends-on", + "display": "QICore model information", + "resource": "http://hl7.org/fhir/Library/QICore-ModelInfo" + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://ecqi.healthit.gov/ecqms/Library/FHIRHelpers|4.4.000" + }, + { + "type": "depends-on", + "display": "Library Hospice", + "resource": "http://ecqi.healthit.gov/ecqms/Library/Hospice|6.12.000" + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": "http://ecqi.healthit.gov/ecqms/Library/PalliativeCare|1.11.000" + }, + { + "type": "depends-on", + "display": "Library Status", + "resource": "http://ecqi.healthit.gov/ecqms/Library/Status|1.8.000" + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, + { + "type": "depends-on", + "display": "Code system AdministrativeGender", + "resource": "http://hl7.org/fhir/administrative-gender" + }, + { + "type": "depends-on", + "display": "Value set Congenital or Acquired Absence of Cervix", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + }, + { + "type": "depends-on", + "display": "Value set Hysterectomy with No Residual Cervix", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + }, + { + "type": "depends-on", + "display": "Value set Encounter Inpatient", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + }, + { + "type": "depends-on", + "display": "Value set Payer Type", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "Qualifying Encounters", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Absence of Cervix", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Cervical Cytology Within 3 Years", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "HPV Test Within 5 Years for Women Age 30 and Older", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "SDE Ethnicity", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Payer", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "SDE Race", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Sex", + "use": "out", + "min": 0, + "max": "1", + "type": "Coding" + } + ], + "dataRequirement": [ + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ], + "mustSupport": ["ethnicity", "race"] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ] + }, + { + "path": "value" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ] + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Coverage", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-coverage" + ], + "mustSupport": ["type", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + ] + } + ], + "content": [ + { + "contentType": "text/cql", + "data": "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" + }, + { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1" localId="0">
   <annotation translatorVersion="3.10.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" signatureLevel="None" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:s r="587">
         <a:s>library CervicalCancerScreeningFHIR version '0.0.001'</a:s>
      </a:s>
   </annotation>
   <identifier id="CervicalCancerScreeningFHIR" system="http://ecqi.healthit.gov/ecqms" version="0.0.001"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localId="1" localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="206" locator="3:1-3:28" localIdentifier="QICore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="206">
               <a:s>using </a:s>
               <a:s>
                  <a:s>QICore</a:s>
               </a:s>
               <a:s> version '4.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="207" locator="5:1-5:56" localIdentifier="FHIRHelpers" path="http://ecqi.healthit.gov/ecqms/FHIRHelpers" version="4.4.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="207">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.4.000' called FHIRHelpers</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="208" locator="6:1-6:61" localIdentifier="SDE" path="http://ecqi.healthit.gov/ecqms/SupplementalDataElements" version="3.5.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="208">
               <a:s>include </a:s>
               <a:s>
                  <a:s>SupplementalDataElements</a:s>
               </a:s>
               <a:s> version '3.5.000' called SDE</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="209" locator="7:1-7:58" localIdentifier="QICoreCommon" path="http://ecqi.healthit.gov/ecqms/QICoreCommon" version="2.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="209">
               <a:s>include </a:s>
               <a:s>
                  <a:s>QICoreCommon</a:s>
               </a:s>
               <a:s> version '2.1.000' called QICoreCommon</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="210" locator="8:1-8:49" localIdentifier="Hospice" path="http://ecqi.healthit.gov/ecqms/Hospice" version="6.12.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="210">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Hospice</a:s>
               </a:s>
               <a:s> version '6.12.000' called Hospice</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="211" locator="9:1-9:63" localIdentifier="PalliativeCare" path="http://ecqi.healthit.gov/ecqms/PalliativeCare" version="1.11.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="211">
               <a:s>include </a:s>
               <a:s>
                  <a:s>PalliativeCare</a:s>
               </a:s>
               <a:s> version '1.11.000' called PalliativeCare</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="212" locator="10:1-10:46" localIdentifier="Status" path="http://ecqi.healthit.gov/ecqms/Status" version="1.8.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="212">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Status</a:s>
               </a:s>
               <a:s> version '1.8.000' called Status</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <parameters>
      <def localId="223" locator="23:1-23:49" name="Measurement Period" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="223">
               <a:s>parameter &quot;Measurement Period&quot; </a:s>
               <a:s r="224">
                  <a:s>Interval&lt;</a:s>
                  <a:s r="225">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
            </a:s>
         </annotation>
         <parameterTypeSpecifier localId="224" locator="23:32-23:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="225" locator="23:41-23:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <valueSets>
      <def localId="213" locator="12:1-12:132" name="Congenital or Acquired Absence of Cervix" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="213">
               <a:s>valueset &quot;Congenital or Acquired Absence of Cervix&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="214" locator="13:1-13:116" name="Home Healthcare Services" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="214">
               <a:s>valueset &quot;Home Healthcare Services&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="215" locator="14:1-14:100" name="HPV Test" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="215">
               <a:s>valueset &quot;HPV Test&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="216" locator="15:1-15:128" name="Hysterectomy with No Residual Cervix" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="216">
               <a:s>valueset &quot;Hysterectomy with No Residual Cervix&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="217" locator="16:1-16:104" name="Office Visit" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="217">
               <a:s>valueset &quot;Office Visit&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="218" locator="17:1-17:109" name="Virtual Encounter" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="218">
               <a:s>valueset &quot;Virtual Encounter&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="219" locator="18:1-18:100" name="Pap Test" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="219">
               <a:s>valueset &quot;Pap Test&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="220" locator="19:1-19:152" name="Preventive Care Services Established Office Visit, 18 and Up" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="220">
               <a:s>valueset &quot;Preventive Care Services Established Office Visit, 18 and Up&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="221" locator="20:1-20:148" name="Preventive Care Services Initial Office Visit, 18 and Up" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="221">
               <a:s>valueset &quot;Preventive Care Services Initial Office Visit, 18 and Up&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="222" locator="21:1-21:108" name="Telephone Visits" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="222">
               <a:s>valueset &quot;Telephone Visits&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080'</a:s>
            </a:s>
         </annotation>
      </def>
   </valueSets>
   <contexts>
      <def localId="229" locator="25:1-25:15" name="Patient"/>
   </contexts>
   <statements>
      <def localId="227" locator="25:1-25:15" name="Patient" context="Patient">
         <expression localId="228" xsi:type="SingletonFrom">
            <operand localId="226" locator="25:1-25:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="254" locator="34:1-42:82" name="Qualifying Encounters" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="254">
               <a:s>define &quot;Qualifying Encounters&quot;:
  </a:s>
               <a:s r="304">
                  <a:s>
                     <a:s r="255">
                        <a:s r="287">
                           <a:s>( </a:s>
                           <a:s r="287">
                              <a:s r="286">
                                 <a:s>( </a:s>
                                 <a:s r="286">
                                    <a:s r="280">
                                       <a:s r="275">
                                          <a:s r="269">
                                             <a:s r="264">
                                                <a:s r="258">
                                                   <a:s>[&quot;Encounter&quot;: </a:s>
                                                   <a:s>
                                                      <a:s>&quot;Office Visit&quot;</a:s>
                                                   </a:s>
                                                   <a:s>]</a:s>
                                                </a:s>
                                                <a:s>
      union </a:s>
                                                <a:s r="262">
                                                   <a:s>[Encounter: </a:s>
                                                   <a:s>
                                                      <a:s>&quot;Preventive Care Services Established Office Visit, 18 and Up&quot;</a:s>
                                                   </a:s>
                                                   <a:s>]</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
      union </a:s>
                                             <a:s r="267">
                                                <a:s>[Encounter: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Preventive Care Services Initial Office Visit, 18 and Up&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
      union </a:s>
                                          <a:s r="272">
                                             <a:s>[Encounter: </a:s>
                                             <a:s>
                                                <a:s>&quot;Home Healthcare Services&quot;</a:s>
                                             </a:s>
                                             <a:s>]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>
      union </a:s>
                                       <a:s r="278">
                                          <a:s>[Encounter: </a:s>
                                          <a:s>
                                             <a:s>&quot;Telephone Visits&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
      union </a:s>
                                    <a:s r="283">
                                       <a:s>[Encounter: </a:s>
                                       <a:s>
                                          <a:s>&quot;Virtual Encounter&quot;</a:s>
                                       </a:s>
                                       <a:s>]</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
  )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="287">
                                 <a:s>isEncounterPerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> ValidEncounters</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="302">
                     <a:s>where </a:s>
                     <a:s r="302">
                        <a:s r="291">
                           <a:s r="290">
                              <a:s r="288">
                                 <a:s>ValidEncounters</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="290">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="291">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="302"> during day of </a:s>
                        <a:s r="301">
                           <a:s>&quot;Measurement Period&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="304" locator="35:3-42:82" xsi:type="Query">
            <source localId="255" locator="35:3-41:46" alias="ValidEncounters">
               <expression localId="287" locator="35:3-41:30" name="isEncounterPerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="286" locator="35:5-41:3" xsi:type="Union">
                     <operand localId="275" locator="35:7-38:51" xsi:type="Union">
                        <operand localId="264" locator="35:7-36:87" xsi:type="Union">
                           <operand localId="258" locator="35:7-35:35" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="257" locator="35:21-35:34" name="Office Visit" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                           <operand localId="262" locator="36:13-36:87" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="261" locator="36:25-36:86" name="Preventive Care Services Established Office Visit, 18 and Up" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                        </operand>
                        <operand localId="274" xsi:type="Union">
                           <operand localId="267" locator="37:13-37:83" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="266" locator="37:25-37:82" name="Preventive Care Services Initial Office Visit, 18 and Up" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                           <operand localId="272" locator="38:13-38:51" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                              <codes localId="271" locator="38:25-38:50" name="Home Healthcare Services" preserve="true" xsi:type="ValueSetRef"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="285" xsi:type="Union">
                        <operand localId="278" locator="39:13-39:43" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="277" locator="39:25-39:42" name="Telephone Visits" preserve="true" xsi:type="ValueSetRef"/>
                        </operand>
                        <operand localId="283" locator="40:13-40:44" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" codeProperty="type" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="282" locator="40:25-40:43" name="Virtual Encounter" preserve="true" xsi:type="ValueSetRef"/>
                        </operand>
                     </operand>
                  </operand>
               </expression>
            </source>
            <where localId="302" locator="42:5-42:82" precision="Day" xsi:type="IncludedIn">
               <operand localId="291" locator="42:11-42:47" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                  <operand localId="292" xsi:type="As">
                     <operand localId="290" locator="42:11-42:32" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="289" path="period" scope="ValidEncounters" xsi:type="Property"/>
                     </operand>
                     <asTypeSpecifier localId="293" xsi:type="ChoiceTypeSpecifier">
                        <choice localId="294" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                        <choice localId="295" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        <choice localId="296" xsi:type="IntervalTypeSpecifier">
                           <pointType localId="297" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                        </choice>
                        <choice localId="298" xsi:type="IntervalTypeSpecifier">
                           <pointType localId="299" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        </choice>
                        <choice localId="300" name="fhir:Timing" xsi:type="NamedTypeSpecifier"/>
                     </asTypeSpecifier>
                  </operand>
               </operand>
               <operand localId="301" locator="42:63-42:82" name="Measurement Period" xsi:type="ParameterRef"/>
            </where>
         </expression>
      </def>
      <def localId="231" locator="27:1-32:38" name="Initial Population" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="231">
               <a:s>define &quot;Initial Population&quot;:
  </a:s>
               <a:s r="232">
                  <a:s r="233">
                     <a:s r="246">
                        <a:s r="242">
                           <a:s>AgeInYearsAt(</a:s>
                           <a:s r="234">
                              <a:s>date from 
    </a:s>
                              <a:s r="235">
                                 <a:s>end of </a:s>
                                 <a:s r="236">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
  )</a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="245">
                           <a:s r="243">Interval[24, 64]</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    and </a:s>
                     <a:s r="247">
                        <a:s r="250">
                           <a:s r="248">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="250">
                              <a:s>gender</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="251">
                           <a:s>'female'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    and </a:s>
                  <a:s r="252">
                     <a:s>exists </a:s>
                     <a:s r="305">
                        <a:s>&quot;Qualifying Encounters&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="232" locator="28:3-32:38" xsi:type="And">
            <operand localId="233" locator="28:3-31:33" xsi:type="And">
               <operand localId="246" locator="28:3-30:23" xsi:type="In">
                  <operand localId="242" locator="28:3-30:3" precision="Year" xsi:type="CalculateAgeAt">
                     <operand localId="241" path="value" xsi:type="Property">
                        <source localId="240" path="birthDate" xsi:type="Property">
                           <source localId="239" name="Patient" xsi:type="ExpressionRef"/>
                        </source>
                     </operand>
                     <operand localId="234" locator="28:16-29:31" xsi:type="DateFrom">
                        <operand localId="235" locator="29:5-29:31" xsi:type="End">
                           <operand localId="236" locator="29:12-29:31" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="245" locator="30:8-30:23" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="243" locator="30:17-30:18" valueType="t:Integer" value="24" xsi:type="Literal"/>
                     <high localId="244" locator="30:21-30:22" valueType="t:Integer" value="64" xsi:type="Literal"/>
                  </operand>
               </operand>
               <operand localId="247" locator="31:9-31:33" xsi:type="Equal">
                  <operand localId="250" locator="31:9-31:22" path="value" xsi:type="Property">
                     <source localId="249" path="gender" xsi:type="Property">
                        <source localId="248" locator="31:9-31:15" name="Patient" xsi:type="ExpressionRef"/>
                     </source>
                  </operand>
                  <operand localId="251" locator="31:26-31:33" valueType="t:String" value="female" xsi:type="Literal"/>
               </operand>
            </operand>
            <operand localId="252" locator="32:9-32:38" xsi:type="Exists">
               <operand localId="305" locator="32:16-32:38" name="Qualifying Encounters" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="307" locator="44:1-45:22" name="Denominator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="307">
               <a:s>define &quot;Denominator&quot;:
  </a:s>
               <a:s r="308">
                  <a:s>&quot;Initial Population&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="308" locator="45:3-45:22" name="Initial Population" xsi:type="ExpressionRef"/>
      </def>
      <def localId="317" locator="56:1-62:5" name="Absence of Cervix" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="317">
               <a:s>define &quot;Absence of Cervix&quot;:
  </a:s>
               <a:s r="355">
                  <a:s r="332">
                     <a:s>( </a:s>
                     <a:s r="332">
                        <a:s>
                           <a:s r="318">
                              <a:s r="323">
                                 <a:s>( </a:s>
                                 <a:s r="323">
                                    <a:s r="321">
                                       <a:s>( </a:s>
                                       <a:s r="321">
                                          <a:s>[Procedure: </a:s>
                                          <a:s>
                                             <a:s>&quot;Hysterectomy with No Residual Cervix&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                       <a:s> )</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="323">
                                       <a:s>isProcedurePerformed ( )</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s> NoCervixProcedure</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="331">
                           <a:s>where </a:s>
                           <a:s r="331">
                              <a:s r="327">
                                 <a:s r="326">
                                    <a:s r="324">
                                       <a:s>NoCervixProcedure</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="326">
                                       <a:s>performed</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="327">
                                    <a:s>toInterval ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="331"> ends on or before </a:s>
                              <a:s r="328">
                                 <a:s>end of </a:s>
                                 <a:s r="329">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
                  <a:s>
    union </a:s>
                  <a:s r="344">
                     <a:s>( </a:s>
                     <a:s r="344">
                        <a:s>
                           <a:s r="333">
                              <a:s r="336">
                                 <a:s r="336">
                                    <a:s>[Condition: </a:s>
                                    <a:s>
                                       <a:s>&quot;Congenital or Acquired Absence of Cervix&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> NoCervixDiagnosis</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
        </a:s>
                        <a:s r="343">
                           <a:s>where </a:s>
                           <a:s r="343">
                              <a:s r="339">
                                 <a:s r="338">
                                    <a:s>NoCervixDiagnosis</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="339">
                                    <a:s>prevalenceInterval ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="343"> starts on or before </a:s>
                              <a:s r="340">
                                 <a:s>end of </a:s>
                                 <a:s r="341">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="355" locator="57:3-62:5" xsi:type="Union">
            <operand localId="345" xsi:type="As">
               <operand localId="332" locator="57:3-59:3" xsi:type="Query">
                  <source localId="318" locator="57:5-57:106" alias="NoCervixProcedure">
                     <expression localId="323" locator="57:5-57:88" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                        <operand localId="321" locator="57:7-57:61" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="320" locator="57:21-57:58" name="Hysterectomy with No Residual Cervix" preserve="true" xsi:type="ValueSetRef"/>
                        </operand>
                     </expression>
                  </source>
                  <where localId="331" locator="58:7-58:100" xsi:type="SameOrBefore">
                     <operand localId="330" locator="58:56-58:59" xsi:type="End">
                        <operand localId="327" locator="58:13-58:54" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                           <operand localId="326" locator="58:13-58:39" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="325" path="performed" scope="NoCervixProcedure" xsi:type="Property"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="328" locator="58:74-58:100" xsi:type="End">
                        <operand localId="329" locator="58:81-58:100" name="Measurement Period" xsi:type="ParameterRef"/>
                     </operand>
                  </where>
               </operand>
               <asTypeSpecifier localId="346" xsi:type="ListTypeSpecifier">
                  <elementType localId="347" xsi:type="ChoiceTypeSpecifier">
                     <choice localId="348" name="fhir:Procedure" xsi:type="NamedTypeSpecifier"/>
                     <choice localId="349" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
                  </elementType>
               </asTypeSpecifier>
            </operand>
            <operand localId="350" xsi:type="As">
               <operand localId="344" locator="60:11-62:5" xsi:type="Query">
                  <source localId="333" locator="60:13-60:85" alias="NoCervixDiagnosis">
                     <expression localId="336" locator="60:13-60:67" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                        <codes localId="335" locator="60:25-60:66" name="Congenital or Acquired Absence of Cervix" preserve="true" xsi:type="ValueSetRef"/>
                     </expression>
                  </source>
                  <where localId="343" locator="61:9-61:102" xsi:type="SameOrBefore">
                     <operand localId="342" locator="61:56-61:61" xsi:type="Start">
                        <operand localId="339" locator="61:15-61:54" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                           <operand localId="338" locator="61:15-61:31" name="NoCervixDiagnosis" xsi:type="AliasRef"/>
                        </operand>
                     </operand>
                     <operand localId="340" locator="61:76-61:102" xsi:type="End">
                        <operand localId="341" locator="61:83-61:102" name="Measurement Period" xsi:type="ParameterRef"/>
                     </operand>
                  </where>
               </operand>
               <asTypeSpecifier localId="351" xsi:type="ListTypeSpecifier">
                  <elementType localId="352" xsi:type="ChoiceTypeSpecifier">
                     <choice localId="353" name="fhir:Procedure" xsi:type="NamedTypeSpecifier"/>
                     <choice localId="354" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
                  </elementType>
               </asTypeSpecifier>
            </operand>
         </expression>
      </def>
      <def localId="310" locator="47:1-50:69" name="Denominator Exclusions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="310">
               <a:s>define &quot;Denominator Exclusions&quot;:
  </a:s>
               <a:s r="311">
                  <a:s r="312">
                     <a:s r="314">
                        <a:s r="313">
                           <a:s>Hospice</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="314">
                           <a:s>&quot;Has Hospice Services&quot;</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="315">
                        <a:s>exists </a:s>
                        <a:s r="356">
                           <a:s>&quot;Absence of Cervix&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    or </a:s>
                  <a:s r="358">
                     <a:s r="357">
                        <a:s>PalliativeCare</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="358">
                        <a:s>&quot;Has Palliative Care in the Measurement Period&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="311" locator="48:3-50:69" xsi:type="Or">
            <operand localId="312" locator="48:3-49:33" xsi:type="Or">
               <operand localId="314" locator="48:3-48:32" name="Has Hospice Services" libraryName="Hospice" xsi:type="ExpressionRef"/>
               <operand localId="315" locator="49:8-49:33" xsi:type="Exists">
                  <operand localId="356" locator="49:15-49:33" name="Absence of Cervix" xsi:type="ExpressionRef"/>
               </operand>
            </operand>
            <operand localId="358" locator="50:8-50:69" name="Has Palliative Care in the Measurement Period" libraryName="PalliativeCare" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="364" locator="64:1-67:44" name="Cervical Cytology Within 3 Years" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="364">
               <a:s>define &quot;Cervical Cytology Within 3 Years&quot;:
  </a:s>
               <a:s r="436">
                  <a:s>
                     <a:s r="365">
                        <a:s r="370">
                           <a:s>( </a:s>
                           <a:s r="370">
                              <a:s r="368">
                                 <a:s>( </a:s>
                                 <a:s r="368">
                                    <a:s>[Observation: </a:s>
                                    <a:s>
                                       <a:s>&quot;Pap Test&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="370">
                                 <a:s>isLaboratoryTestPerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> CervicalCytology</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="371">
                     <a:s>where </a:s>
                     <a:s r="371">
                        <a:s r="430">
                           <a:s r="375">
                              <a:s r="374">
                                 <a:s r="372">
                                    <a:s>CervicalCytology</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="374">
                                    <a:s>effective</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="375">
                                 <a:s>latest ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="430"> during day of </a:s>
                           <a:s r="428">
                              <a:s>Interval[</a:s>
                              <a:s r="422">
                                 <a:s r="423">
                                    <a:s>start of </a:s>
                                    <a:s r="424">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> - </a:s>
                                 <a:s r="425">
                                    <a:s>2 years</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="426">
                                 <a:s>end of </a:s>
                                 <a:s r="427">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="435">
                           <a:s r="433">
                              <a:s r="431">
                                 <a:s>CervicalCytology</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="433">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s> is not null</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="436" locator="65:3-67:44" xsi:type="Query">
            <source localId="365" locator="65:3-65:82" alias="CervicalCytology">
               <expression localId="370" locator="65:3-65:65" name="isLaboratoryTestPerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="368" locator="65:5-65:33" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="367" locator="65:21-65:30" name="Pap Test" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="371" locator="66:5-67:44" xsi:type="And">
               <operand localId="430" locator="66:11-66:140" precision="Day" xsi:type="In">
                  <operand localId="375" locator="66:11-66:47" name="latest" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="385" xsi:type="Case">
                        <caseItem localId="386">
                           <when localId="387" isType="t:DateTime" xsi:type="Is">
                              <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                              </operand>
                           </when>
                           <then localId="377" xsi:type="As">
                              <operand localId="376" asType="t:DateTime" xsi:type="As">
                                 <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                                 </operand>
                              </operand>
                              <asTypeSpecifier localId="378" xsi:type="ChoiceTypeSpecifier">
                                 <choice localId="379" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="380" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="381" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="382" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice localId="383" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="384" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <caseItem localId="388">
                           <when localId="389" xsi:type="Is">
                              <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                              </operand>
                              <isTypeSpecifier localId="390" xsi:type="IntervalTypeSpecifier">
                                 <pointType localId="391" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </isTypeSpecifier>
                           </when>
                           <then localId="395" xsi:type="As">
                              <operand localId="392" xsi:type="As">
                                 <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                                 </operand>
                                 <asTypeSpecifier localId="393" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="394" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </asTypeSpecifier>
                              </operand>
                              <asTypeSpecifier localId="396" xsi:type="ChoiceTypeSpecifier">
                                 <choice localId="397" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="398" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="399" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="400" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice localId="401" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="402" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <caseItem localId="403">
                           <when localId="404" isType="t:DateTime" xsi:type="Is">
                              <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                              </operand>
                           </when>
                           <then localId="406" xsi:type="As">
                              <operand localId="405" asType="t:DateTime" xsi:type="As">
                                 <operand localId="374" locator="66:11-66:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="373" path="effective" scope="CervicalCytology" xsi:type="Property"/>
                                 </operand>
                              </operand>
                              <asTypeSpecifier localId="407" xsi:type="ChoiceTypeSpecifier">
                                 <choice localId="408" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="409" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice localId="410" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="411" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice localId="412" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="413" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <else localId="414" xsi:type="Null"/>
                     </operand>
                  </operand>
                  <operand localId="428" locator="66:63-66:140" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="422" locator="66:72-66:110" xsi:type="Subtract">
                        <operand localId="423" locator="66:72-66:100" xsi:type="Start">
                           <operand localId="424" locator="66:81-66:100" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                        <operand localId="425" locator="66:104-66:110" value="2" unit="years" xsi:type="Quantity"/>
                     </low>
                     <high localId="426" locator="66:113-66:139" xsi:type="End">
                        <operand localId="427" locator="66:120-66:139" name="Measurement Period" xsi:type="ParameterRef"/>
                     </high>
                  </operand>
               </operand>
               <operand localId="435" locator="67:11-67:44" xsi:type="Not">
                  <operand localId="434" locator="67:11-67:44" xsi:type="IsNull">
                     <operand localId="433" locator="67:11-67:32" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="432" path="value" scope="CervicalCytology" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="440" locator="69:1-73:35" name="HPV Test Within 5 Years for Women Age 30 and Older" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="440">
               <a:s>define &quot;HPV Test Within 5 Years for Women Age 30 and Older&quot;:
  </a:s>
               <a:s r="572">
                  <a:s>
                     <a:s r="441">
                        <a:s r="446">
                           <a:s>( </a:s>
                           <a:s r="446">
                              <a:s r="444">
                                 <a:s>( </a:s>
                                 <a:s r="444">
                                    <a:s>[Observation: </a:s>
                                    <a:s>
                                       <a:s>&quot;HPV Test&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="446">
                                 <a:s>isLaboratoryTestPerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> HPVTest</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="447">
                     <a:s>where </a:s>
                     <a:s r="447">
                        <a:s r="448">
                           <a:s r="449">
                              <a:s r="506">
                                 <a:s>AgeInYearsAt(</a:s>
                                 <a:s r="450">
                                    <a:s>date from </a:s>
                                    <a:s r="454">
                                       <a:s r="453">
                                          <a:s r="451">
                                             <a:s>HPVTest</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="453">
                                             <a:s>effective</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="454">
                                          <a:s>latest()</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s r="507"> >= 30</a:s>
                           </a:s>
                           <a:s>
      and </a:s>
                           <a:s r="566">
                              <a:s r="511">
                                 <a:s r="510">
                                    <a:s r="508">
                                       <a:s>HPVTest</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="510">
                                       <a:s>effective</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="511">
                                    <a:s>latest ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="566"> during day of </a:s>
                              <a:s r="564">
                                 <a:s>Interval[</a:s>
                                 <a:s r="558">
                                    <a:s r="559">
                                       <a:s>start of </a:s>
                                       <a:s r="560">
                                          <a:s>&quot;Measurement Period&quot;</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> - </a:s>
                                    <a:s r="561">
                                       <a:s>4 years</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="562">
                                    <a:s>end of </a:s>
                                    <a:s r="563">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="571">
                           <a:s r="569">
                              <a:s r="567">
                                 <a:s>HPVTest</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="569">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s> is not null</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="572" locator="70:3-73:35" xsi:type="Query">
            <source localId="441" locator="70:3-70:73" alias="HPVTest">
               <expression localId="446" locator="70:3-70:65" name="isLaboratoryTestPerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="444" locator="70:5-70:33" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="443" locator="70:21-70:30" name="HPV Test" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="447" locator="71:5-73:35" xsi:type="And">
               <operand localId="448" locator="71:11-72:131" xsi:type="And">
                  <operand localId="449" locator="71:11-71:66" xsi:type="GreaterOrEqual">
                     <operand localId="506" locator="71:11-71:60" precision="Year" xsi:type="CalculateAgeAt">
                        <operand localId="505" path="value" xsi:type="Property">
                           <source localId="504" path="birthDate" xsi:type="Property">
                              <source localId="503" name="Patient" xsi:type="ExpressionRef"/>
                           </source>
                        </operand>
                        <operand localId="450" locator="71:24-71:59" xsi:type="DateFrom">
                           <operand localId="454" locator="71:34-71:59" name="latest" libraryName="QICoreCommon" xsi:type="FunctionRef">
                              <operand localId="464" xsi:type="Case">
                                 <caseItem localId="465">
                                    <when localId="466" isType="t:DateTime" xsi:type="Is">
                                       <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                       </operand>
                                    </when>
                                    <then localId="456" xsi:type="As">
                                       <operand localId="455" asType="t:DateTime" xsi:type="As">
                                          <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="457" xsi:type="ChoiceTypeSpecifier">
                                          <choice localId="458" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="459" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="460" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="461" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                          <choice localId="462" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="463" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                       </asTypeSpecifier>
                                    </then>
                                 </caseItem>
                                 <caseItem localId="467">
                                    <when localId="468" xsi:type="Is">
                                       <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                       </operand>
                                       <isTypeSpecifier localId="469" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="470" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </isTypeSpecifier>
                                    </when>
                                    <then localId="474" xsi:type="As">
                                       <operand localId="471" xsi:type="As">
                                          <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                          </operand>
                                          <asTypeSpecifier localId="472" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="473" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </asTypeSpecifier>
                                       </operand>
                                       <asTypeSpecifier localId="475" xsi:type="ChoiceTypeSpecifier">
                                          <choice localId="476" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="477" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="478" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="479" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                          <choice localId="480" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="481" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                       </asTypeSpecifier>
                                    </then>
                                 </caseItem>
                                 <caseItem localId="482">
                                    <when localId="483" isType="t:DateTime" xsi:type="Is">
                                       <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                       </operand>
                                    </when>
                                    <then localId="485" xsi:type="As">
                                       <operand localId="484" asType="t:DateTime" xsi:type="As">
                                          <operand localId="453" locator="71:34-71:50" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand localId="452" path="effective" scope="HPVTest" xsi:type="Property"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="486" xsi:type="ChoiceTypeSpecifier">
                                          <choice localId="487" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="488" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          <choice localId="489" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="490" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                          <choice localId="491" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="492" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </choice>
                                       </asTypeSpecifier>
                                    </then>
                                 </caseItem>
                                 <else localId="493" xsi:type="Null"/>
                              </operand>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="507" locator="71:65-71:66" valueType="t:Integer" value="30" xsi:type="Literal"/>
                  </operand>
                  <operand localId="566" locator="72:11-72:131" precision="Day" xsi:type="In">
                     <operand localId="511" locator="72:11-72:38" name="latest" libraryName="QICoreCommon" xsi:type="FunctionRef">
                        <operand localId="521" xsi:type="Case">
                           <caseItem localId="522">
                              <when localId="523" isType="t:DateTime" xsi:type="Is">
                                 <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                 </operand>
                              </when>
                              <then localId="513" xsi:type="As">
                                 <operand localId="512" asType="t:DateTime" xsi:type="As">
                                    <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                    </operand>
                                 </operand>
                                 <asTypeSpecifier localId="514" xsi:type="ChoiceTypeSpecifier">
                                    <choice localId="515" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="516" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="517" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="518" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                    <choice localId="519" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="520" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                 </asTypeSpecifier>
                              </then>
                           </caseItem>
                           <caseItem localId="524">
                              <when localId="525" xsi:type="Is">
                                 <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                 </operand>
                                 <isTypeSpecifier localId="526" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="527" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </isTypeSpecifier>
                              </when>
                              <then localId="531" xsi:type="As">
                                 <operand localId="528" xsi:type="As">
                                    <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                    </operand>
                                    <asTypeSpecifier localId="529" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="530" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </operand>
                                 <asTypeSpecifier localId="532" xsi:type="ChoiceTypeSpecifier">
                                    <choice localId="533" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="534" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="535" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="536" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                    <choice localId="537" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="538" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                 </asTypeSpecifier>
                              </then>
                           </caseItem>
                           <caseItem localId="539">
                              <when localId="540" isType="t:DateTime" xsi:type="Is">
                                 <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                 </operand>
                              </when>
                              <then localId="542" xsi:type="As">
                                 <operand localId="541" asType="t:DateTime" xsi:type="As">
                                    <operand localId="510" locator="72:11-72:27" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="509" path="effective" scope="HPVTest" xsi:type="Property"/>
                                    </operand>
                                 </operand>
                                 <asTypeSpecifier localId="543" xsi:type="ChoiceTypeSpecifier">
                                    <choice localId="544" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="545" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    <choice localId="546" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="547" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                    <choice localId="548" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="549" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </choice>
                                 </asTypeSpecifier>
                              </then>
                           </caseItem>
                           <else localId="550" xsi:type="Null"/>
                        </operand>
                     </operand>
                     <operand localId="564" locator="72:54-72:131" lowClosed="true" highClosed="true" xsi:type="Interval">
                        <low localId="558" locator="72:63-72:101" xsi:type="Subtract">
                           <operand localId="559" locator="72:63-72:91" xsi:type="Start">
                              <operand localId="560" locator="72:72-72:91" name="Measurement Period" xsi:type="ParameterRef"/>
                           </operand>
                           <operand localId="561" locator="72:95-72:101" value="4" unit="years" xsi:type="Quantity"/>
                        </low>
                        <high localId="562" locator="72:104-72:130" xsi:type="End">
                           <operand localId="563" locator="72:111-72:130" name="Measurement Period" xsi:type="ParameterRef"/>
                        </high>
                     </operand>
                  </operand>
               </operand>
               <operand localId="571" locator="73:11-73:35" xsi:type="Not">
                  <operand localId="570" locator="73:11-73:35" xsi:type="IsNull">
                     <operand localId="569" locator="73:11-73:23" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="568" path="value" scope="HPVTest" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="360" locator="52:1-54:66" name="Numerator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="360">
               <a:s>define &quot;Numerator&quot;:
  </a:s>
               <a:s r="361">
                  <a:s r="362">
                     <a:s>exists </a:s>
                     <a:s r="437">
                        <a:s>&quot;Cervical Cytology Within 3 Years&quot;</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    or </a:s>
                  <a:s r="438">
                     <a:s>exists </a:s>
                     <a:s r="573">
                        <a:s>&quot;HPV Test Within 5 Years for Women Age 30 and Older&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="361" locator="53:3-54:66" xsi:type="Or">
            <operand localId="362" locator="53:3-53:43" xsi:type="Exists">
               <operand localId="437" locator="53:10-53:43" name="Cervical Cytology Within 3 Years" xsi:type="ExpressionRef"/>
            </operand>
            <operand localId="438" locator="54:8-54:66" xsi:type="Exists">
               <operand localId="573" locator="54:15-54:66" name="HPV Test Within 5 Years for Women Age 30 and Older" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="575" locator="75:1-76:21" name="SDE Ethnicity" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="575">
               <a:s>define &quot;SDE Ethnicity&quot;:
  </a:s>
               <a:s r="577">
                  <a:s r="576">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="577">
                     <a:s>&quot;SDE Ethnicity&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="577" locator="76:3-76:21" name="SDE Ethnicity" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="579" locator="78:1-79:17" name="SDE Payer" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="579">
               <a:s>define &quot;SDE Payer&quot;:
  </a:s>
               <a:s r="581">
                  <a:s r="580">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="581">
                     <a:s>&quot;SDE Payer&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="581" locator="79:3-79:17" name="SDE Payer" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="583" locator="81:1-82:16" name="SDE Race" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="583">
               <a:s>define &quot;SDE Race&quot;:
  </a:s>
               <a:s r="585">
                  <a:s r="584">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="585">
                     <a:s>&quot;SDE Race&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="585" locator="82:3-82:16" name="SDE Race" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="587" locator="84:1-85:15" name="SDE Sex" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="587">
               <a:s>define &quot;SDE Sex&quot;:
  </a:s>
               <a:s r="589">
                  <a:s r="588">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="589">
                     <a:s>&quot;SDE Sex&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="589" locator="85:3-85:15" name="SDE Sex" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
   </statements>
</library>
" + }, + { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "localId" : "0",
      "annotation" : [ {
         "translatorVersion" : "3.10.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "signatureLevel" : "None",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "s" : {
            "r" : "587",
            "s" : [ {
               "value" : [ "","library CervicalCancerScreeningFHIR version '0.0.001'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "CervicalCancerScreeningFHIR",
         "system" : "http://ecqi.healthit.gov/ecqms",
         "version" : "0.0.001"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localId" : "1",
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "206",
            "locator" : "3:1-3:28",
            "localIdentifier" : "QICore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "206",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICore" ]
                     } ]
                  }, {
                     "value" : [ " version '4.1.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "207",
            "locator" : "5:1-5:56",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://ecqi.healthit.gov/ecqms/FHIRHelpers",
            "version" : "4.4.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "207",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.4.000'"," called ","FHIRHelpers" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "208",
            "locator" : "6:1-6:61",
            "localIdentifier" : "SDE",
            "path" : "http://ecqi.healthit.gov/ecqms/SupplementalDataElements",
            "version" : "3.5.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "208",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "SupplementalDataElements" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.5.000'"," called ","SDE" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "209",
            "locator" : "7:1-7:58",
            "localIdentifier" : "QICoreCommon",
            "path" : "http://ecqi.healthit.gov/ecqms/QICoreCommon",
            "version" : "2.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "209",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'2.1.000'"," called ","QICoreCommon" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "210",
            "locator" : "8:1-8:49",
            "localIdentifier" : "Hospice",
            "path" : "http://ecqi.healthit.gov/ecqms/Hospice",
            "version" : "6.12.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "210",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Hospice" ]
                     } ]
                  }, {
                     "value" : [ " version ","'6.12.000'"," called ","Hospice" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "211",
            "locator" : "9:1-9:63",
            "localIdentifier" : "PalliativeCare",
            "path" : "http://ecqi.healthit.gov/ecqms/PalliativeCare",
            "version" : "1.11.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "211",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "PalliativeCare" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.11.000'"," called ","PalliativeCare" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "212",
            "locator" : "10:1-10:46",
            "localIdentifier" : "Status",
            "path" : "http://ecqi.healthit.gov/ecqms/Status",
            "version" : "1.8.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "212",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Status" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.8.000'"," called ","Status" ]
                  } ]
               }
            } ]
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "223",
            "locator" : "23:1-23:49",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "223",
                  "s" : [ {
                     "value" : [ "","parameter ","\"Measurement Period\""," " ]
                  }, {
                     "r" : "224",
                     "s" : [ {
                        "value" : [ "Interval<" ]
                     }, {
                        "r" : "225",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  } ]
               }
            } ],
            "parameterTypeSpecifier" : {
               "localId" : "224",
               "locator" : "23:32-23:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "225",
                  "locator" : "23:41-23:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "213",
            "locator" : "12:1-12:132",
            "name" : "Congenital or Acquired Absence of Cervix",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "213",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Congenital or Acquired Absence of Cervix\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.111.12.1016'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "214",
            "locator" : "13:1-13:116",
            "name" : "Home Healthcare Services",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "214",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Home Healthcare Services\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "215",
            "locator" : "14:1-14:100",
            "name" : "HPV Test",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "215",
                  "s" : [ {
                     "value" : [ "","valueset ","\"HPV Test\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1059'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "216",
            "locator" : "15:1-15:128",
            "name" : "Hysterectomy with No Residual Cervix",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "216",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Hysterectomy with No Residual Cervix\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1014'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "217",
            "locator" : "16:1-16:104",
            "name" : "Office Visit",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "217",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Office Visit\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "218",
            "locator" : "17:1-17:109",
            "name" : "Virtual Encounter",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "218",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Virtual Encounter\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "219",
            "locator" : "18:1-18:100",
            "name" : "Pap Test",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "219",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Pap Test\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1017'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "220",
            "locator" : "19:1-19:152",
            "name" : "Preventive Care Services Established Office Visit, 18 and Up",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "220",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Preventive Care Services Established Office Visit, 18 and Up\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "221",
            "locator" : "20:1-20:148",
            "name" : "Preventive Care Services Initial Office Visit, 18 and Up",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "221",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Preventive Care Services Initial Office Visit, 18 and Up\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "222",
            "locator" : "21:1-21:108",
            "name" : "Telephone Visits",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "222",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Telephone Visits\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         } ]
      },
      "contexts" : {
         "def" : [ {
            "localId" : "229",
            "locator" : "25:1-25:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "localId" : "227",
            "locator" : "25:1-25:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "localId" : "228",
               "type" : "SingletonFrom",
               "signature" : [ ],
               "operand" : {
                  "localId" : "226",
                  "locator" : "25:1-25:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient",
                  "type" : "Retrieve",
                  "include" : [ ],
                  "codeFilter" : [ ],
                  "dateFilter" : [ ],
                  "otherFilter" : [ ]
               }
            }
         }, {
            "localId" : "254",
            "locator" : "34:1-42:82",
            "name" : "Qualifying Encounters",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "254",
                  "s" : [ {
                     "value" : [ "","define ","\"Qualifying Encounters\"",":\n  " ]
                  }, {
                     "r" : "304",
                     "s" : [ {
                        "s" : [ {
                           "r" : "255",
                           "s" : [ {
                              "r" : "287",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "287",
                                 "s" : [ {
                                    "r" : "286",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "286",
                                       "s" : [ {
                                          "r" : "280",
                                          "s" : [ {
                                             "r" : "275",
                                             "s" : [ {
                                                "r" : "269",
                                                "s" : [ {
                                                   "r" : "264",
                                                   "s" : [ {
                                                      "r" : "258",
                                                      "s" : [ {
                                                         "value" : [ "[","\"Encounter\"",": " ]
                                                      }, {
                                                         "s" : [ {
                                                            "value" : [ "\"Office Visit\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "]" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n      union " ]
                                                   }, {
                                                      "r" : "262",
                                                      "s" : [ {
                                                         "value" : [ "[","Encounter",": " ]
                                                      }, {
                                                         "s" : [ {
                                                            "value" : [ "\"Preventive Care Services Established Office Visit, 18 and Up\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "]" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n      union " ]
                                                }, {
                                                   "r" : "267",
                                                   "s" : [ {
                                                      "value" : [ "[","Encounter",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Preventive Care Services Initial Office Visit, 18 and Up\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n      union " ]
                                             }, {
                                                "r" : "272",
                                                "s" : [ {
                                                   "value" : [ "[","Encounter",": " ]
                                                }, {
                                                   "s" : [ {
                                                      "value" : [ "\"Home Healthcare Services\"" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "\n      union " ]
                                          }, {
                                             "r" : "278",
                                             "s" : [ {
                                                "value" : [ "[","Encounter",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Telephone Visits\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n      union " ]
                                       }, {
                                          "r" : "283",
                                          "s" : [ {
                                             "value" : [ "[","Encounter",": " ]
                                          }, {
                                             "s" : [ {
                                                "value" : [ "\"Virtual Encounter\"" ]
                                             } ]
                                          }, {
                                             "value" : [ "]" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n  )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "287",
                                    "s" : [ {
                                       "value" : [ "isEncounterPerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","ValidEncounters" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "302",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "302",
                           "s" : [ {
                              "r" : "291",
                              "s" : [ {
                                 "r" : "290",
                                 "s" : [ {
                                    "r" : "288",
                                    "s" : [ {
                                       "value" : [ "ValidEncounters" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "290",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "291",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "302",
                              "value" : [ " ","during day of"," " ]
                           }, {
                              "r" : "301",
                              "s" : [ {
                                 "value" : [ "\"Measurement Period\"" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "304",
               "locator" : "35:3-42:82",
               "type" : "Query",
               "source" : [ {
                  "localId" : "255",
                  "locator" : "35:3-41:46",
                  "alias" : "ValidEncounters",
                  "expression" : {
                     "localId" : "287",
                     "locator" : "35:3-41:30",
                     "name" : "isEncounterPerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "286",
                        "locator" : "35:5-41:3",
                        "type" : "Union",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "275",
                           "locator" : "35:7-38:51",
                           "type" : "Union",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "264",
                              "locator" : "35:7-36:87",
                              "type" : "Union",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "258",
                                 "locator" : "35:7-35:35",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "257",
                                    "locator" : "35:21-35:34",
                                    "name" : "Office Visit",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              }, {
                                 "localId" : "262",
                                 "locator" : "36:13-36:87",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "261",
                                    "locator" : "36:25-36:86",
                                    "name" : "Preventive Care Services Established Office Visit, 18 and Up",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              } ]
                           }, {
                              "localId" : "274",
                              "type" : "Union",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "267",
                                 "locator" : "37:13-37:83",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "266",
                                    "locator" : "37:25-37:82",
                                    "name" : "Preventive Care Services Initial Office Visit, 18 and Up",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              }, {
                                 "localId" : "272",
                                 "locator" : "38:13-38:51",
                                 "dataType" : "{http://hl7.org/fhir}Encounter",
                                 "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                                 "codeProperty" : "type",
                                 "codeComparator" : "in",
                                 "type" : "Retrieve",
                                 "codes" : {
                                    "localId" : "271",
                                    "locator" : "38:25-38:50",
                                    "name" : "Home Healthcare Services",
                                    "preserve" : true,
                                    "type" : "ValueSetRef"
                                 },
                                 "include" : [ ],
                                 "codeFilter" : [ ],
                                 "dateFilter" : [ ],
                                 "otherFilter" : [ ]
                              } ]
                           } ]
                        }, {
                           "localId" : "285",
                           "type" : "Union",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "278",
                              "locator" : "39:13-39:43",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                              "codeProperty" : "type",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "277",
                                 "locator" : "39:25-39:42",
                                 "name" : "Telephone Visits",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }, {
                              "localId" : "283",
                              "locator" : "40:13-40:44",
                              "dataType" : "{http://hl7.org/fhir}Encounter",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter",
                              "codeProperty" : "type",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "282",
                                 "locator" : "40:25-40:43",
                                 "name" : "Virtual Encounter",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           } ]
                        } ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "302",
                  "locator" : "42:5-42:82",
                  "precision" : "Day",
                  "type" : "IncludedIn",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "291",
                     "locator" : "42:11-42:47",
                     "name" : "toInterval",
                     "libraryName" : "QICoreCommon",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "292",
                        "type" : "As",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "290",
                           "locator" : "42:11-42:32",
                           "name" : "ToInterval",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "289",
                              "path" : "period",
                              "scope" : "ValidEncounters",
                              "type" : "Property"
                           } ]
                        },
                        "asTypeSpecifier" : {
                           "localId" : "293",
                           "type" : "ChoiceTypeSpecifier",
                           "type" : [ ],
                           "choice" : [ {
                              "localId" : "294",
                              "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                              "type" : "NamedTypeSpecifier"
                           }, {
                              "localId" : "295",
                              "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                              "type" : "NamedTypeSpecifier"
                           }, {
                              "localId" : "296",
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "localId" : "297",
                                 "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }, {
                              "localId" : "298",
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "localId" : "299",
                                 "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }, {
                              "localId" : "300",
                              "name" : "{http://hl7.org/fhir}Timing",
                              "type" : "NamedTypeSpecifier"
                           } ]
                        }
                     } ]
                  }, {
                     "localId" : "301",
                     "locator" : "42:63-42:82",
                     "name" : "Measurement Period",
                     "type" : "ParameterRef"
                  } ]
               }
            }
         }, {
            "localId" : "231",
            "locator" : "27:1-32:38",
            "name" : "Initial Population",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "231",
                  "s" : [ {
                     "value" : [ "","define ","\"Initial Population\"",":\n  " ]
                  }, {
                     "r" : "232",
                     "s" : [ {
                        "r" : "233",
                        "s" : [ {
                           "r" : "246",
                           "s" : [ {
                              "r" : "242",
                              "s" : [ {
                                 "value" : [ "AgeInYearsAt","(" ]
                              }, {
                                 "r" : "234",
                                 "s" : [ {
                                    "value" : [ "date from \n    " ]
                                 }, {
                                    "r" : "235",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "236",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n  )" ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "245",
                              "s" : [ {
                                 "r" : "243",
                                 "value" : [ "Interval[","24",", ","64","]" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    and " ]
                        }, {
                           "r" : "247",
                           "s" : [ {
                              "r" : "250",
                              "s" : [ {
                                 "r" : "248",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "250",
                                 "s" : [ {
                                    "value" : [ "gender" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "251",
                              "s" : [ {
                                 "value" : [ "'female'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    and " ]
                     }, {
                        "r" : "252",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "305",
                           "s" : [ {
                              "value" : [ "\"Qualifying Encounters\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "232",
               "locator" : "28:3-32:38",
               "type" : "And",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "233",
                  "locator" : "28:3-31:33",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "246",
                     "locator" : "28:3-30:23",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "242",
                        "locator" : "28:3-30:3",
                        "precision" : "Year",
                        "type" : "CalculateAgeAt",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "241",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "240",
                              "path" : "birthDate",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "239",
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           }
                        }, {
                           "localId" : "234",
                           "locator" : "28:16-29:31",
                           "type" : "DateFrom",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "235",
                              "locator" : "29:5-29:31",
                              "type" : "End",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "236",
                                 "locator" : "29:12-29:31",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "localId" : "245",
                        "locator" : "30:8-30:23",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "243",
                           "locator" : "30:17-30:18",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "24",
                           "type" : "Literal"
                        },
                        "high" : {
                           "localId" : "244",
                           "locator" : "30:21-30:22",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "64",
                           "type" : "Literal"
                        }
                     } ]
                  }, {
                     "localId" : "247",
                     "locator" : "31:9-31:33",
                     "type" : "Equal",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "250",
                        "locator" : "31:9-31:22",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "249",
                           "path" : "gender",
                           "type" : "Property",
                           "source" : {
                              "localId" : "248",
                              "locator" : "31:9-31:15",
                              "name" : "Patient",
                              "type" : "ExpressionRef"
                           }
                        }
                     }, {
                        "localId" : "251",
                        "locator" : "31:26-31:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "female",
                        "type" : "Literal"
                     } ]
                  } ]
               }, {
                  "localId" : "252",
                  "locator" : "32:9-32:38",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "305",
                     "locator" : "32:16-32:38",
                     "name" : "Qualifying Encounters",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "307",
            "locator" : "44:1-45:22",
            "name" : "Denominator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "307",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator\"",":\n  " ]
                  }, {
                     "r" : "308",
                     "s" : [ {
                        "value" : [ "\"Initial Population\"" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "308",
               "locator" : "45:3-45:22",
               "name" : "Initial Population",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "317",
            "locator" : "56:1-62:5",
            "name" : "Absence of Cervix",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "317",
                  "s" : [ {
                     "value" : [ "","define ","\"Absence of Cervix\"",":\n  " ]
                  }, {
                     "r" : "355",
                     "s" : [ {
                        "r" : "332",
                        "s" : [ {
                           "value" : [ "( " ]
                        }, {
                           "r" : "332",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "318",
                                 "s" : [ {
                                    "r" : "323",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "323",
                                       "s" : [ {
                                          "r" : "321",
                                          "s" : [ {
                                             "value" : [ "( " ]
                                          }, {
                                             "r" : "321",
                                             "s" : [ {
                                                "value" : [ "[","Procedure",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Hysterectomy with No Residual Cervix\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          }, {
                                             "value" : [ " )" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "323",
                                          "s" : [ {
                                             "value" : [ "isProcedurePerformed"," ( )" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ " ","NoCervixProcedure" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "331",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "331",
                                 "s" : [ {
                                    "r" : "327",
                                    "s" : [ {
                                       "r" : "326",
                                       "s" : [ {
                                          "r" : "324",
                                          "s" : [ {
                                             "value" : [ "NoCervixProcedure" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "326",
                                          "s" : [ {
                                             "value" : [ "performed" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "327",
                                       "s" : [ {
                                          "value" : [ "toInterval"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "331",
                                    "value" : [ " ","ends on or before"," " ]
                                 }, {
                                    "r" : "328",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "329",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     }, {
                        "value" : [ "\n    union " ]
                     }, {
                        "r" : "344",
                        "s" : [ {
                           "value" : [ "( " ]
                        }, {
                           "r" : "344",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "333",
                                 "s" : [ {
                                    "r" : "336",
                                    "s" : [ {
                                       "r" : "336",
                                       "s" : [ {
                                          "value" : [ "[","Condition",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Congenital or Acquired Absence of Cervix\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","NoCervixDiagnosis" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n        " ]
                           }, {
                              "r" : "343",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "343",
                                 "s" : [ {
                                    "r" : "339",
                                    "s" : [ {
                                       "r" : "338",
                                       "s" : [ {
                                          "value" : [ "NoCervixDiagnosis" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "339",
                                       "s" : [ {
                                          "value" : [ "prevalenceInterval"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "343",
                                    "value" : [ " ","starts on or before"," " ]
                                 }, {
                                    "r" : "340",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "341",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "355",
               "locator" : "57:3-62:5",
               "type" : "Union",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "345",
                  "type" : "As",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "332",
                     "locator" : "57:3-59:3",
                     "type" : "Query",
                     "source" : [ {
                        "localId" : "318",
                        "locator" : "57:5-57:106",
                        "alias" : "NoCervixProcedure",
                        "expression" : {
                           "localId" : "323",
                           "locator" : "57:5-57:88",
                           "name" : "isProcedurePerformed",
                           "libraryName" : "Status",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "321",
                              "locator" : "57:7-57:61",
                              "dataType" : "{http://hl7.org/fhir}Procedure",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "320",
                                 "locator" : "57:21-57:58",
                                 "name" : "Hysterectomy with No Residual Cervix",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           } ]
                        }
                     } ],
                     "let" : [ ],
                     "relationship" : [ ],
                     "where" : {
                        "localId" : "331",
                        "locator" : "58:7-58:100",
                        "type" : "SameOrBefore",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "330",
                           "locator" : "58:56-58:59",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "327",
                              "locator" : "58:13-58:54",
                              "name" : "toInterval",
                              "libraryName" : "QICoreCommon",
                              "type" : "FunctionRef",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "326",
                                 "locator" : "58:13-58:39",
                                 "name" : "ToValue",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "325",
                                    "path" : "performed",
                                    "scope" : "NoCervixProcedure",
                                    "type" : "Property"
                                 } ]
                              } ]
                           }
                        }, {
                           "localId" : "328",
                           "locator" : "58:74-58:100",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "329",
                              "locator" : "58:81-58:100",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        } ]
                     }
                  },
                  "asTypeSpecifier" : {
                     "localId" : "346",
                     "type" : "ListTypeSpecifier",
                     "elementType" : {
                        "localId" : "347",
                        "type" : "ChoiceTypeSpecifier",
                        "type" : [ ],
                        "choice" : [ {
                           "localId" : "348",
                           "name" : "{http://hl7.org/fhir}Procedure",
                           "type" : "NamedTypeSpecifier"
                        }, {
                           "localId" : "349",
                           "name" : "{http://hl7.org/fhir}Condition",
                           "type" : "NamedTypeSpecifier"
                        } ]
                     }
                  }
               }, {
                  "localId" : "350",
                  "type" : "As",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "344",
                     "locator" : "60:11-62:5",
                     "type" : "Query",
                     "source" : [ {
                        "localId" : "333",
                        "locator" : "60:13-60:85",
                        "alias" : "NoCervixDiagnosis",
                        "expression" : {
                           "localId" : "336",
                           "locator" : "60:13-60:67",
                           "dataType" : "{http://hl7.org/fhir}Condition",
                           "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                           "codeProperty" : "code",
                           "codeComparator" : "in",
                           "type" : "Retrieve",
                           "codes" : {
                              "localId" : "335",
                              "locator" : "60:25-60:66",
                              "name" : "Congenital or Acquired Absence of Cervix",
                              "preserve" : true,
                              "type" : "ValueSetRef"
                           },
                           "include" : [ ],
                           "codeFilter" : [ ],
                           "dateFilter" : [ ],
                           "otherFilter" : [ ]
                        }
                     } ],
                     "let" : [ ],
                     "relationship" : [ ],
                     "where" : {
                        "localId" : "343",
                        "locator" : "61:9-61:102",
                        "type" : "SameOrBefore",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "342",
                           "locator" : "61:56-61:61",
                           "type" : "Start",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "339",
                              "locator" : "61:15-61:54",
                              "name" : "prevalenceInterval",
                              "libraryName" : "QICoreCommon",
                              "type" : "FunctionRef",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "338",
                                 "locator" : "61:15-61:31",
                                 "name" : "NoCervixDiagnosis",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }, {
                           "localId" : "340",
                           "locator" : "61:76-61:102",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "341",
                              "locator" : "61:83-61:102",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        } ]
                     }
                  },
                  "asTypeSpecifier" : {
                     "localId" : "351",
                     "type" : "ListTypeSpecifier",
                     "elementType" : {
                        "localId" : "352",
                        "type" : "ChoiceTypeSpecifier",
                        "type" : [ ],
                        "choice" : [ {
                           "localId" : "353",
                           "name" : "{http://hl7.org/fhir}Procedure",
                           "type" : "NamedTypeSpecifier"
                        }, {
                           "localId" : "354",
                           "name" : "{http://hl7.org/fhir}Condition",
                           "type" : "NamedTypeSpecifier"
                        } ]
                     }
                  }
               } ]
            }
         }, {
            "localId" : "310",
            "locator" : "47:1-50:69",
            "name" : "Denominator Exclusions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "310",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator Exclusions\"",":\n  " ]
                  }, {
                     "r" : "311",
                     "s" : [ {
                        "r" : "312",
                        "s" : [ {
                           "r" : "314",
                           "s" : [ {
                              "r" : "313",
                              "s" : [ {
                                 "value" : [ "Hospice" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "314",
                              "s" : [ {
                                 "value" : [ "\"Has Hospice Services\"" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "315",
                           "s" : [ {
                              "value" : [ "exists " ]
                           }, {
                              "r" : "356",
                              "s" : [ {
                                 "value" : [ "\"Absence of Cervix\"" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    or " ]
                     }, {
                        "r" : "358",
                        "s" : [ {
                           "r" : "357",
                           "s" : [ {
                              "value" : [ "PalliativeCare" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "358",
                           "s" : [ {
                              "value" : [ "\"Has Palliative Care in the Measurement Period\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "311",
               "locator" : "48:3-50:69",
               "type" : "Or",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "312",
                  "locator" : "48:3-49:33",
                  "type" : "Or",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "314",
                     "locator" : "48:3-48:32",
                     "name" : "Has Hospice Services",
                     "libraryName" : "Hospice",
                     "type" : "ExpressionRef"
                  }, {
                     "localId" : "315",
                     "locator" : "49:8-49:33",
                     "type" : "Exists",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "356",
                        "locator" : "49:15-49:33",
                        "name" : "Absence of Cervix",
                        "type" : "ExpressionRef"
                     }
                  } ]
               }, {
                  "localId" : "358",
                  "locator" : "50:8-50:69",
                  "name" : "Has Palliative Care in the Measurement Period",
                  "libraryName" : "PalliativeCare",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "364",
            "locator" : "64:1-67:44",
            "name" : "Cervical Cytology Within 3 Years",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "364",
                  "s" : [ {
                     "value" : [ "","define ","\"Cervical Cytology Within 3 Years\"",":\n  " ]
                  }, {
                     "r" : "436",
                     "s" : [ {
                        "s" : [ {
                           "r" : "365",
                           "s" : [ {
                              "r" : "370",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "370",
                                 "s" : [ {
                                    "r" : "368",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "368",
                                       "s" : [ {
                                          "value" : [ "[","Observation",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Pap Test\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "370",
                                    "s" : [ {
                                       "value" : [ "isLaboratoryTestPerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","CervicalCytology" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "371",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "371",
                           "s" : [ {
                              "r" : "430",
                              "s" : [ {
                                 "r" : "375",
                                 "s" : [ {
                                    "r" : "374",
                                    "s" : [ {
                                       "r" : "372",
                                       "s" : [ {
                                          "value" : [ "CervicalCytology" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "374",
                                       "s" : [ {
                                          "value" : [ "effective" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "375",
                                    "s" : [ {
                                       "value" : [ "latest"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "430",
                                 "value" : [ " ","during day of"," " ]
                              }, {
                                 "r" : "428",
                                 "s" : [ {
                                    "value" : [ "Interval[" ]
                                 }, {
                                    "r" : "422",
                                    "s" : [ {
                                       "r" : "423",
                                       "s" : [ {
                                          "value" : [ "start of " ]
                                       }, {
                                          "r" : "424",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " - " ]
                                    }, {
                                       "r" : "425",
                                       "s" : [ {
                                          "value" : [ "2 ","years" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "426",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "427",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "435",
                              "s" : [ {
                                 "r" : "433",
                                 "s" : [ {
                                    "r" : "431",
                                    "s" : [ {
                                       "value" : [ "CervicalCytology" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "433",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " is not null" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "436",
               "locator" : "65:3-67:44",
               "type" : "Query",
               "source" : [ {
                  "localId" : "365",
                  "locator" : "65:3-65:82",
                  "alias" : "CervicalCytology",
                  "expression" : {
                     "localId" : "370",
                     "locator" : "65:3-65:65",
                     "name" : "isLaboratoryTestPerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "368",
                        "locator" : "65:5-65:33",
                        "dataType" : "{http://hl7.org/fhir}Observation",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "367",
                           "locator" : "65:21-65:30",
                           "name" : "Pap Test",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "371",
                  "locator" : "66:5-67:44",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "430",
                     "locator" : "66:11-66:140",
                     "precision" : "Day",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "375",
                        "locator" : "66:11-66:47",
                        "name" : "latest",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "385",
                           "type" : "Case",
                           "caseItem" : [ {
                              "localId" : "386",
                              "when" : {
                                 "localId" : "387",
                                 "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "Is",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "374",
                                    "locator" : "66:11-66:36",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "373",
                                       "path" : "effective",
                                       "scope" : "CervicalCytology",
                                       "type" : "Property"
                                    } ]
                                 }
                              },
                              "then" : {
                                 "localId" : "377",
                                 "type" : "As",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "376",
                                    "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "374",
                                       "locator" : "66:11-66:36",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "373",
                                          "path" : "effective",
                                          "scope" : "CervicalCytology",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "localId" : "378",
                                    "type" : "ChoiceTypeSpecifier",
                                    "type" : [ ],
                                    "choice" : [ {
                                       "localId" : "379",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "380",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "381",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "382",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "localId" : "383",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "384",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           }, {
                              "localId" : "388",
                              "when" : {
                                 "localId" : "389",
                                 "type" : "Is",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "374",
                                    "locator" : "66:11-66:36",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "373",
                                       "path" : "effective",
                                       "scope" : "CervicalCytology",
                                       "type" : "Property"
                                    } ]
                                 },
                                 "isTypeSpecifier" : {
                                    "localId" : "390",
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "localId" : "391",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "localId" : "395",
                                 "type" : "As",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "392",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "374",
                                       "locator" : "66:11-66:36",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "373",
                                          "path" : "effective",
                                          "scope" : "CervicalCytology",
                                          "type" : "Property"
                                       } ]
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "393",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "394",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "localId" : "396",
                                    "type" : "ChoiceTypeSpecifier",
                                    "type" : [ ],
                                    "choice" : [ {
                                       "localId" : "397",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "398",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "399",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "400",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "localId" : "401",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "402",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           }, {
                              "localId" : "403",
                              "when" : {
                                 "localId" : "404",
                                 "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "Is",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "374",
                                    "locator" : "66:11-66:36",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "373",
                                       "path" : "effective",
                                       "scope" : "CervicalCytology",
                                       "type" : "Property"
                                    } ]
                                 }
                              },
                              "then" : {
                                 "localId" : "406",
                                 "type" : "As",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "405",
                                    "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "374",
                                       "locator" : "66:11-66:36",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "373",
                                          "path" : "effective",
                                          "scope" : "CervicalCytology",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "localId" : "407",
                                    "type" : "ChoiceTypeSpecifier",
                                    "type" : [ ],
                                    "choice" : [ {
                                       "localId" : "408",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "409",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "localId" : "410",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "411",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "localId" : "412",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "413",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           } ],
                           "else" : {
                              "localId" : "414",
                              "type" : "Null"
                           }
                        } ]
                     }, {
                        "localId" : "428",
                        "locator" : "66:63-66:140",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "422",
                           "locator" : "66:72-66:110",
                           "type" : "Subtract",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "423",
                              "locator" : "66:72-66:100",
                              "type" : "Start",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "424",
                                 "locator" : "66:81-66:100",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }, {
                              "localId" : "425",
                              "locator" : "66:104-66:110",
                              "value" : 2,
                              "unit" : "years",
                              "type" : "Quantity"
                           } ]
                        },
                        "high" : {
                           "localId" : "426",
                           "locator" : "66:113-66:139",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "427",
                              "locator" : "66:120-66:139",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        }
                     } ]
                  }, {
                     "localId" : "435",
                     "locator" : "67:11-67:44",
                     "type" : "Not",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "434",
                        "locator" : "67:11-67:44",
                        "type" : "IsNull",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "433",
                           "locator" : "67:11-67:32",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "432",
                              "path" : "value",
                              "scope" : "CervicalCytology",
                              "type" : "Property"
                           } ]
                        }
                     }
                  } ]
               }
            }
         }, {
            "localId" : "440",
            "locator" : "69:1-73:35",
            "name" : "HPV Test Within 5 Years for Women Age 30 and Older",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "440",
                  "s" : [ {
                     "value" : [ "","define ","\"HPV Test Within 5 Years for Women Age 30 and Older\"",":\n  " ]
                  }, {
                     "r" : "572",
                     "s" : [ {
                        "s" : [ {
                           "r" : "441",
                           "s" : [ {
                              "r" : "446",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "446",
                                 "s" : [ {
                                    "r" : "444",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "444",
                                       "s" : [ {
                                          "value" : [ "[","Observation",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"HPV Test\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "446",
                                    "s" : [ {
                                       "value" : [ "isLaboratoryTestPerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","HPVTest" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "447",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "447",
                           "s" : [ {
                              "r" : "448",
                              "s" : [ {
                                 "r" : "449",
                                 "s" : [ {
                                    "r" : "506",
                                    "s" : [ {
                                       "value" : [ "AgeInYearsAt","(" ]
                                    }, {
                                       "r" : "450",
                                       "s" : [ {
                                          "value" : [ "date from " ]
                                       }, {
                                          "r" : "454",
                                          "s" : [ {
                                             "r" : "453",
                                             "s" : [ {
                                                "r" : "451",
                                                "s" : [ {
                                                   "value" : [ "HPVTest" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "453",
                                                "s" : [ {
                                                   "value" : [ "effective" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "454",
                                             "s" : [ {
                                                "value" : [ "latest","()" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "r" : "507",
                                    "value" : [ " ",">="," ","30" ]
                                 } ]
                              }, {
                                 "value" : [ "\n      and " ]
                              }, {
                                 "r" : "566",
                                 "s" : [ {
                                    "r" : "511",
                                    "s" : [ {
                                       "r" : "510",
                                       "s" : [ {
                                          "r" : "508",
                                          "s" : [ {
                                             "value" : [ "HPVTest" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "510",
                                          "s" : [ {
                                             "value" : [ "effective" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "511",
                                       "s" : [ {
                                          "value" : [ "latest"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "566",
                                    "value" : [ " ","during day of"," " ]
                                 }, {
                                    "r" : "564",
                                    "s" : [ {
                                       "value" : [ "Interval[" ]
                                    }, {
                                       "r" : "558",
                                       "s" : [ {
                                          "r" : "559",
                                          "s" : [ {
                                             "value" : [ "start of " ]
                                          }, {
                                             "r" : "560",
                                             "s" : [ {
                                                "value" : [ "\"Measurement Period\"" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " - " ]
                                       }, {
                                          "r" : "561",
                                          "s" : [ {
                                             "value" : [ "4 ","years" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "562",
                                       "s" : [ {
                                          "value" : [ "end of " ]
                                       }, {
                                          "r" : "563",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "571",
                              "s" : [ {
                                 "r" : "569",
                                 "s" : [ {
                                    "r" : "567",
                                    "s" : [ {
                                       "value" : [ "HPVTest" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "569",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " is not null" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "572",
               "locator" : "70:3-73:35",
               "type" : "Query",
               "source" : [ {
                  "localId" : "441",
                  "locator" : "70:3-70:73",
                  "alias" : "HPVTest",
                  "expression" : {
                     "localId" : "446",
                     "locator" : "70:3-70:65",
                     "name" : "isLaboratoryTestPerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "444",
                        "locator" : "70:5-70:33",
                        "dataType" : "{http://hl7.org/fhir}Observation",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "443",
                           "locator" : "70:21-70:30",
                           "name" : "HPV Test",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "447",
                  "locator" : "71:5-73:35",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "448",
                     "locator" : "71:11-72:131",
                     "type" : "And",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "449",
                        "locator" : "71:11-71:66",
                        "type" : "GreaterOrEqual",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "506",
                           "locator" : "71:11-71:60",
                           "precision" : "Year",
                           "type" : "CalculateAgeAt",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "505",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "504",
                                 "path" : "birthDate",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "503",
                                    "name" : "Patient",
                                    "type" : "ExpressionRef"
                                 }
                              }
                           }, {
                              "localId" : "450",
                              "locator" : "71:24-71:59",
                              "type" : "DateFrom",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "454",
                                 "locator" : "71:34-71:59",
                                 "name" : "latest",
                                 "libraryName" : "QICoreCommon",
                                 "type" : "FunctionRef",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "464",
                                    "type" : "Case",
                                    "caseItem" : [ {
                                       "localId" : "465",
                                       "when" : {
                                          "localId" : "466",
                                          "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "Is",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "453",
                                             "locator" : "71:34-71:50",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "signature" : [ ],
                                             "operand" : [ {
                                                "localId" : "452",
                                                "path" : "effective",
                                                "scope" : "HPVTest",
                                                "type" : "Property"
                                             } ]
                                          }
                                       },
                                       "then" : {
                                          "localId" : "456",
                                          "type" : "As",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "455",
                                             "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "As",
                                             "signature" : [ ],
                                             "operand" : {
                                                "localId" : "453",
                                                "locator" : "71:34-71:50",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "signature" : [ ],
                                                "operand" : [ {
                                                   "localId" : "452",
                                                   "path" : "effective",
                                                   "scope" : "HPVTest",
                                                   "type" : "Property"
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "457",
                                             "type" : "ChoiceTypeSpecifier",
                                             "type" : [ ],
                                             "choice" : [ {
                                                "localId" : "458",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "459",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "460",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "461",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }, {
                                                "localId" : "462",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "463",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }
                                       }
                                    }, {
                                       "localId" : "467",
                                       "when" : {
                                          "localId" : "468",
                                          "type" : "Is",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "453",
                                             "locator" : "71:34-71:50",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "signature" : [ ],
                                             "operand" : [ {
                                                "localId" : "452",
                                                "path" : "effective",
                                                "scope" : "HPVTest",
                                                "type" : "Property"
                                             } ]
                                          },
                                          "isTypeSpecifier" : {
                                             "localId" : "469",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "470",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       },
                                       "then" : {
                                          "localId" : "474",
                                          "type" : "As",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "471",
                                             "type" : "As",
                                             "signature" : [ ],
                                             "operand" : {
                                                "localId" : "453",
                                                "locator" : "71:34-71:50",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "signature" : [ ],
                                                "operand" : [ {
                                                   "localId" : "452",
                                                   "path" : "effective",
                                                   "scope" : "HPVTest",
                                                   "type" : "Property"
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "472",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "473",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "475",
                                             "type" : "ChoiceTypeSpecifier",
                                             "type" : [ ],
                                             "choice" : [ {
                                                "localId" : "476",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "477",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "478",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "479",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }, {
                                                "localId" : "480",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "481",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }
                                       }
                                    }, {
                                       "localId" : "482",
                                       "when" : {
                                          "localId" : "483",
                                          "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "Is",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "453",
                                             "locator" : "71:34-71:50",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "signature" : [ ],
                                             "operand" : [ {
                                                "localId" : "452",
                                                "path" : "effective",
                                                "scope" : "HPVTest",
                                                "type" : "Property"
                                             } ]
                                          }
                                       },
                                       "then" : {
                                          "localId" : "485",
                                          "type" : "As",
                                          "signature" : [ ],
                                          "operand" : {
                                             "localId" : "484",
                                             "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "As",
                                             "signature" : [ ],
                                             "operand" : {
                                                "localId" : "453",
                                                "locator" : "71:34-71:50",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "signature" : [ ],
                                                "operand" : [ {
                                                   "localId" : "452",
                                                   "path" : "effective",
                                                   "scope" : "HPVTest",
                                                   "type" : "Property"
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "486",
                                             "type" : "ChoiceTypeSpecifier",
                                             "type" : [ ],
                                             "choice" : [ {
                                                "localId" : "487",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "488",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }, {
                                                "localId" : "489",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "490",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }, {
                                                "localId" : "491",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "492",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }
                                       }
                                    } ],
                                    "else" : {
                                       "localId" : "493",
                                       "type" : "Null"
                                    }
                                 } ]
                              }
                           } ]
                        }, {
                           "localId" : "507",
                           "locator" : "71:65-71:66",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "30",
                           "type" : "Literal"
                        } ]
                     }, {
                        "localId" : "566",
                        "locator" : "72:11-72:131",
                        "precision" : "Day",
                        "type" : "In",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "511",
                           "locator" : "72:11-72:38",
                           "name" : "latest",
                           "libraryName" : "QICoreCommon",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "521",
                              "type" : "Case",
                              "caseItem" : [ {
                                 "localId" : "522",
                                 "when" : {
                                    "localId" : "523",
                                    "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "Is",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "510",
                                       "locator" : "72:11-72:27",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "509",
                                          "path" : "effective",
                                          "scope" : "HPVTest",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "then" : {
                                    "localId" : "513",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "512",
                                       "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "As",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "510",
                                          "locator" : "72:11-72:27",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "509",
                                             "path" : "effective",
                                             "scope" : "HPVTest",
                                             "type" : "Property"
                                          } ]
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "514",
                                       "type" : "ChoiceTypeSpecifier",
                                       "type" : [ ],
                                       "choice" : [ {
                                          "localId" : "515",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "516",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "517",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "518",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }, {
                                          "localId" : "519",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "520",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }
                                 }
                              }, {
                                 "localId" : "524",
                                 "when" : {
                                    "localId" : "525",
                                    "type" : "Is",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "510",
                                       "locator" : "72:11-72:27",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "509",
                                          "path" : "effective",
                                          "scope" : "HPVTest",
                                          "type" : "Property"
                                       } ]
                                    },
                                    "isTypeSpecifier" : {
                                       "localId" : "526",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "527",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "then" : {
                                    "localId" : "531",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "528",
                                       "type" : "As",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "510",
                                          "locator" : "72:11-72:27",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "509",
                                             "path" : "effective",
                                             "scope" : "HPVTest",
                                             "type" : "Property"
                                          } ]
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "529",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "530",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "532",
                                       "type" : "ChoiceTypeSpecifier",
                                       "type" : [ ],
                                       "choice" : [ {
                                          "localId" : "533",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "534",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "535",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "536",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }, {
                                          "localId" : "537",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "538",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }
                                 }
                              }, {
                                 "localId" : "539",
                                 "when" : {
                                    "localId" : "540",
                                    "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "Is",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "510",
                                       "locator" : "72:11-72:27",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "signature" : [ ],
                                       "operand" : [ {
                                          "localId" : "509",
                                          "path" : "effective",
                                          "scope" : "HPVTest",
                                          "type" : "Property"
                                       } ]
                                    }
                                 },
                                 "then" : {
                                    "localId" : "542",
                                    "type" : "As",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "541",
                                       "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "As",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "510",
                                          "locator" : "72:11-72:27",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "509",
                                             "path" : "effective",
                                             "scope" : "HPVTest",
                                             "type" : "Property"
                                          } ]
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "543",
                                       "type" : "ChoiceTypeSpecifier",
                                       "type" : [ ],
                                       "choice" : [ {
                                          "localId" : "544",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "545",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "localId" : "546",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "547",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }, {
                                          "localId" : "548",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "549",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }
                                 }
                              } ],
                              "else" : {
                                 "localId" : "550",
                                 "type" : "Null"
                              }
                           } ]
                        }, {
                           "localId" : "564",
                           "locator" : "72:54-72:131",
                           "lowClosed" : true,
                           "highClosed" : true,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "558",
                              "locator" : "72:63-72:101",
                              "type" : "Subtract",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "559",
                                 "locator" : "72:63-72:91",
                                 "type" : "Start",
                                 "signature" : [ ],
                                 "operand" : {
                                    "localId" : "560",
                                    "locator" : "72:72-72:91",
                                    "name" : "Measurement Period",
                                    "type" : "ParameterRef"
                                 }
                              }, {
                                 "localId" : "561",
                                 "locator" : "72:95-72:101",
                                 "value" : 4,
                                 "unit" : "years",
                                 "type" : "Quantity"
                              } ]
                           },
                           "high" : {
                              "localId" : "562",
                              "locator" : "72:104-72:130",
                              "type" : "End",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "563",
                                 "locator" : "72:111-72:130",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     } ]
                  }, {
                     "localId" : "571",
                     "locator" : "73:11-73:35",
                     "type" : "Not",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "570",
                        "locator" : "73:11-73:35",
                        "type" : "IsNull",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "569",
                           "locator" : "73:11-73:23",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "568",
                              "path" : "value",
                              "scope" : "HPVTest",
                              "type" : "Property"
                           } ]
                        }
                     }
                  } ]
               }
            }
         }, {
            "localId" : "360",
            "locator" : "52:1-54:66",
            "name" : "Numerator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "360",
                  "s" : [ {
                     "value" : [ "","define ","\"Numerator\"",":\n  " ]
                  }, {
                     "r" : "361",
                     "s" : [ {
                        "r" : "362",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "437",
                           "s" : [ {
                              "value" : [ "\"Cervical Cytology Within 3 Years\"" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    or " ]
                     }, {
                        "r" : "438",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "573",
                           "s" : [ {
                              "value" : [ "\"HPV Test Within 5 Years for Women Age 30 and Older\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "361",
               "locator" : "53:3-54:66",
               "type" : "Or",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "362",
                  "locator" : "53:3-53:43",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "437",
                     "locator" : "53:10-53:43",
                     "name" : "Cervical Cytology Within 3 Years",
                     "type" : "ExpressionRef"
                  }
               }, {
                  "localId" : "438",
                  "locator" : "54:8-54:66",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "573",
                     "locator" : "54:15-54:66",
                     "name" : "HPV Test Within 5 Years for Women Age 30 and Older",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "575",
            "locator" : "75:1-76:21",
            "name" : "SDE Ethnicity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "575",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Ethnicity\"",":\n  " ]
                  }, {
                     "r" : "577",
                     "s" : [ {
                        "r" : "576",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "577",
                        "s" : [ {
                           "value" : [ "\"SDE Ethnicity\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "577",
               "locator" : "76:3-76:21",
               "name" : "SDE Ethnicity",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "579",
            "locator" : "78:1-79:17",
            "name" : "SDE Payer",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "579",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Payer\"",":\n  " ]
                  }, {
                     "r" : "581",
                     "s" : [ {
                        "r" : "580",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "581",
                        "s" : [ {
                           "value" : [ "\"SDE Payer\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "581",
               "locator" : "79:3-79:17",
               "name" : "SDE Payer",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "583",
            "locator" : "81:1-82:16",
            "name" : "SDE Race",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "583",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Race\"",":\n  " ]
                  }, {
                     "r" : "585",
                     "s" : [ {
                        "r" : "584",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "585",
                        "s" : [ {
                           "value" : [ "\"SDE Race\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "585",
               "locator" : "82:3-82:16",
               "name" : "SDE Race",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "587",
            "locator" : "84:1-85:15",
            "name" : "SDE Sex",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "587",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Sex\"",":\n  " ]
                  }, {
                     "r" : "589",
                     "s" : [ {
                        "r" : "588",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "589",
                        "s" : [ {
                           "value" : [ "\"SDE Sex\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "589",
               "locator" : "85:3-85:15",
               "name" : "SDE Sex",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         } ]
      }
   }
}" + } + ] + }, + "request": { + "method": "PUT", + "url": "Library/CervicalCancerScreeningFHIR" + } + }, + { + "fullUrl": "https://madie.cms.gov/Measure/BreastCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Measure", + "id": "BreastCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/publishable-measure-cqfm", + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/executable-measure-cqfm" + ] + }, + "contained": [ + { + "resourceType": "Library", + "id": "effective-data-requirements", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428361000124107", + "display": "Discharge to home for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "428371000124100", + "display": "Discharge to healthcare facility for hospice care (procedure)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/observation-category", + "code": "survey", + "display": "survey" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "373066001", + "display": "Yes (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "24028007", + "display": "Right (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "7771000", + "display": "Left (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "98181-1", + "display": "Medical equipment used" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "160734000", + "display": "Lives in a nursing home (finding)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "October 1 Two Years Prior to the Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"October 1 Two Years Prior to the Measurement Period\":\n DateTime((year from start of \"Measurement Period\" - 2), 10, 1, 0, 0, 0, 0, 0)" + }, + { + "url": "displaySequence", + "valueInteger": 0 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Numerator" + }, + { + "url": "statement", + "valueString": "define \"Numerator\":\n exists ( ( ( [Observation: \"Mammography\"] ).isDiagnosticStudyPerformed ( ) ) Mammogram\n where Mammogram.effective.toInterval ( ) ends during day of Interval[\"October 1 Two Years Prior to the Measurement Period\", end of \"Measurement Period\"]\n )" + }, + { + "url": "displaySequence", + "valueInteger": 1 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdultOutpatientEncounters" + }, + { + "url": "name", + "valueString": "Qualifying Encounters" + }, + { + "url": "statement", + "valueString": "define \"Qualifying Encounters\":\n ( ( [Encounter: \"Office Visit\"]\n union [Encounter: \"Annual Wellness Visit\"]\n union [Encounter: \"Preventive Care Services Established Office Visit, 18 and Up\"]\n union [Encounter: \"Preventive Care Services Initial Office Visit, 18 and Up\"]\n union [Encounter: \"Home Healthcare Services\"]\n union [Encounter: \"Virtual Encounter\"]\n union [Encounter: \"Telephone Visits\"] ).isEncounterPerformed() ) ValidEncounter\n where ValidEncounter.period.toInterval() during day of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 2 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Initial Population" + }, + { + "url": "statement", + "valueString": "define \"Initial Population\":\n AgeInYearsAt(date from \n end of \"Measurement Period\"\n ) in Interval[52, 74]\n and Patient.gender = 'female'\n and exists AdultOutpatientEncounters.\"Qualifying Encounters\"" + }, + { + "url": "displaySequence", + "valueInteger": 3 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator" + }, + { + "url": "statement", + "valueString": "define \"Denominator\":\n \"Initial Population\"" + }, + { + "url": "displaySequence", + "valueInteger": 4 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Hospice" + }, + { + "url": "name", + "valueString": "Has Hospice Services" + }, + { + "url": "statement", + "valueString": "define \"Has Hospice Services\":\n exists ((([Encounter: \"Encounter Inpatient\"]).isEncounterPerformed()) InpatientEncounter\n where (InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to home for hospice care (procedure)\"\n or InpatientEncounter.hospitalization.dischargeDisposition ~ \"Discharge to healthcare facility for hospice care (procedure)\"\n )\n and InpatientEncounter.period.toInterval() ends during day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Hospice Encounter\"]).isEncounterPerformed()) HospiceEncounter\n where HospiceEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Observation: \"Hospice care [Minimum Data Set]\"]).isAssessmentPerformed()) HospiceAssessment\n where HospiceAssessment.value ~ \"Yes (qualifier value)\"\n and HospiceAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([ServiceRequest: \"Hospice Care Ambulatory\"]).isInterventionOrder()) HospiceOrder\n where HospiceOrder.authoredOn.toInterval() during day of \"Measurement Period\"\n // and HospiceOrder.doNotPerform is not true\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-447\n )\n or exists ((([Procedure: \"Hospice Care Ambulatory\"]).isInterventionPerformed()) HospicePerformed\n where HospicePerformed.performed.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists (([Condition: \"Hospice Diagnosis\"]) HospiceCareDiagnosis\n where HospiceCareDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 5 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Right Mastectomy Diagnosis" + }, + { + "url": "statement", + "valueString": "define \"Right Mastectomy Diagnosis\":\n ( [Condition: \"Status Post Right Mastectomy\"] RightMastectomyProcedure\n union ( [Condition: \"Unilateral Mastectomy, Unspecified Laterality\"] UnilateralMastectomyDiagnosis\n where exists ( UnilateralMastectomyDiagnosis.bodySite S\n where S ~ \"Right (qualifier value)\"\n )\n ) ) RightMastectomy\n where RightMastectomy.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 6 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Right Mastectomy Procedure" + }, + { + "url": "statement", + "valueString": "define \"Right Mastectomy Procedure\":\n ( ( [Procedure: \"Unilateral Mastectomy Right\"] ).isProcedurePerformed ( ) ) UnilateralMastectomyRightPerformed\n where UnilateralMastectomyRightPerformed.performed.toInterval ( ) ends on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 7 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Left Mastectomy Diagnosis" + }, + { + "url": "statement", + "valueString": "define \"Left Mastectomy Diagnosis\":\n ( [Condition: \"Status Post Left Mastectomy\"]\n union ( [Condition: \"Unilateral Mastectomy, Unspecified Laterality\"] UnilateralMastectomyDiagnosis\n where exists ( UnilateralMastectomyDiagnosis.bodySite S\n where S ~ \"Left (qualifier value)\"\n )\n ) ) LeftMastectomy\n where LeftMastectomy.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 8 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Left Mastectomy Procedure" + }, + { + "url": "statement", + "valueString": "define \"Left Mastectomy Procedure\":\n ( ( [Procedure: \"Unilateral Mastectomy Left\"] ).isProcedurePerformed ( ) ) UnilateralMastectomyLeftPerformed\n where UnilateralMastectomyLeftPerformed.performed.toInterval ( ) ends on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 9 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Bilateral Mastectomy Diagnosis" + }, + { + "url": "statement", + "valueString": "define \"Bilateral Mastectomy Diagnosis\":\n [Condition: \"History of bilateral mastectomy\"] BilateralMastectomyHistory\n where BilateralMastectomyHistory.prevalenceInterval ( ) starts on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 10 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Bilateral Mastectomy Procedure" + }, + { + "url": "statement", + "valueString": "define \"Bilateral Mastectomy Procedure\":\n ( ( [Procedure: \"Bilateral Mastectomy\"] ).isProcedurePerformed ( ) ) BilateralMastectomyPerformed\n where BilateralMastectomyPerformed.performed.toInterval ( ) ends on or before end of \"Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 11 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Has Criteria Indicating Frailty" + }, + { + "url": "statement", + "valueString": "define \"Has Criteria Indicating Frailty\":\n exists ( (([DeviceRequest: \"Frailty Device\"]).isDeviceOrder()) FrailtyDeviceOrder\n where FrailtyDeviceOrder.doNotPerform() is not true\n and FrailtyDeviceOrder.authoredOn.toInterval() during day of \"Measurement Period\"\n )\n or exists ( (([Observation: \"Medical equipment used\"]).isAssessmentPerformed()) EquipmentUsed\n where EquipmentUsed.value as Concept in \"Frailty Device\" \n and EquipmentUsed.effective.toInterval() ends during day of \"Measurement Period\"\n )\n or exists ( ([Condition: \"Frailty Diagnosis\"]) FrailtyDiagnosis\n where FrailtyDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )\n or exists ( (([Encounter: \"Frailty Encounter\"]).isEncounterPerformed()) FrailtyEncounter\n where FrailtyEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ( (([Observation: \"Frailty Symptom\"]).isSymptom()) FrailtySymptom\n where FrailtySymptom.effective.toInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 12 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Has Advanced Illness in Year Before or During Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Advanced Illness in Year Before or During Measurement Period\":\nexists ([Condition: \"Advanced Illness\"] AdvancedIllnessDiagnosis\nwhere AdvancedIllnessDiagnosis.prevalenceInterval() starts during day of Interval[start of \"Measurement Period\" - 1 year, end of \"Measurement Period\"])" + }, + { + "url": "displaySequence", + "valueInteger": 13 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Has Dementia Medications in Year Before or During Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Dementia Medications in Year Before or During Measurement Period\":\n exists (( ([MedicationRequest: medication in \"Dementia Medications\"]).isMedicationActive()) DementiaMedication\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-449\n where DementiaMedication.medicationRequestPeriod() overlaps day of Interval[start of \"Measurement Period\" - 1 year, \n end of \"Measurement Period\"]\n // and DementiaMedication.doNotPerform is not true\n // https://oncprojectracking.healthit.gov/support/browse/CQLIT-447\n )" + }, + { + "url": "displaySequence", + "valueInteger": 14 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Is Age 66 or Older with Advanced Illness and Frailty" + }, + { + "url": "statement", + "valueString": "define \"Is Age 66 or Older with Advanced Illness and Frailty\":\n AgeInYearsAt(date from end of \"Measurement Period\")>= 66\n and \"Has Criteria Indicating Frailty\"\n and ( \"Has Advanced Illness in Year Before or During Measurement Period\"\n or \"Has Dementia Medications in Year Before or During Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 15 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "AdvancedIllnessandFrailty" + }, + { + "url": "name", + "valueString": "Is Age 66 or Older Living Long Term in a Nursing Home" + }, + { + "url": "statement", + "valueString": "define \"Is Age 66 or Older Living Long Term in a Nursing Home\":\n AgeInYearsAt(date from \n end of \"Measurement Period\"\n )>= 66\n and ( ( Last( (([Observation: \"Housing status\"]).isAssessmentPerformed()) HousingStatus \n where HousingStatus.effective.toInterval() ends on or before \n day of end of \"Measurement Period\"\n sort by \n end of effective.toInterval() asc\n )) LastHousingStatus\n where LastHousingStatus.value ~ \"Lives in a nursing home (finding)\"\n ) is not null" + }, + { + "url": "displaySequence", + "valueInteger": 16 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "PalliativeCare" + }, + { + "url": "name", + "valueString": "Has Palliative Care in the Measurement Period" + }, + { + "url": "statement", + "valueString": "define \"Has Palliative Care in the Measurement Period\":\n exists ((([Observation: \"Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)\"]).isAssessmentPerformed()) PalliativeAssessment\n where PalliativeAssessment.effective.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ([Condition: \"Palliative Care Diagnosis\"] PalliativeDiagnosis\n where PalliativeDiagnosis.prevalenceInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Encounter: \"Palliative Care Encounter\"]).isEncounterPerformed()) PalliativeEncounter\n where PalliativeEncounter.period.toInterval() overlaps day of \"Measurement Period\"\n )\n or exists ((([Procedure: \"Palliative Care Intervention\"]).isInterventionPerformed()) PalliativeIntervention\n where PalliativeIntervention.performed.toInterval() overlaps day of \"Measurement Period\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 17 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "BreastCancerScreeningFHIR" + }, + { + "url": "name", + "valueString": "Denominator Exclusions" + }, + { + "url": "statement", + "valueString": "define \"Denominator Exclusions\":\n Hospice.\"Has Hospice Services\"\n or ( ( exists ( \"Right Mastectomy Diagnosis\" )\n or exists ( \"Right Mastectomy Procedure\" )\n )\n and ( exists ( \"Left Mastectomy Diagnosis\" )\n or exists ( \"Left Mastectomy Procedure\" )\n )\n )\n or exists \"Bilateral Mastectomy Diagnosis\"\n or exists \"Bilateral Mastectomy Procedure\"\n or AIFrailLTCF.\"Is Age 66 or Older with Advanced Illness and Frailty\"\n or AIFrailLTCF.\"Is Age 66 or Older Living Long Term in a Nursing Home\"\n or PalliativeCare.\"Has Palliative Care in the Measurement Period\"" + }, + { + "url": "displaySequence", + "valueInteger": 18 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isDiagnosticStudyPerformed" + }, + { + "url": "statement", + "valueString": "//Diagnostic Study, Performed\ndefine fluent function isDiagnosticStudyPerformed(Obs List):\n Obs O\n where O.status in {'final', 'amended', 'corrected' }" + }, + { + "url": "displaySequence", + "valueInteger": 19 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isEncounterPerformed" + }, + { + "url": "statement", + "valueString": "//Encounter, Performed\n//General usage unless required otherwise by measure intent (e.g., follow-up encounters)\ndefine fluent function isEncounterPerformed(Enc List):\n Enc E\n where E.status in {'finished', 'arrived', 'triaged', 'in-progress', 'onleave'}" + }, + { + "url": "displaySequence", + "valueInteger": 20 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "toInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval\n@comment: Normalizes a choice type of DateTime, Quanitty, Interval, or Interval types\nto an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible\nrepresentations for timing-valued elements in QICore, allowing this function to be used across any resource.\nThe input can be provided as a DateTime, Quantity, Interval or Interval.\nThe intent of this function is to provide a clear and concise mechanism to treat single\nelements that have multiple possible representations as intervals so that logic doesn't have to account\nfor the variability. More complex calculations (such as medication request period or dispense period\ncalculation) need specific guidance and consideration. That guidance may make use of this function, but\nthe focus of this function is on single element calculations where the semantics are unambiguous.\nIf the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.\nIf the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,\nand the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.\nIf the input is a DateTime Interval, the result is the input.\nIf the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result\nis a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending\nimmediately before one year later than the date the patient turned the age given as the end of the quantity interval.\nIf the input is a Timing, an error will be thrown indicating that Timing calculations are not implemented. Any other input will reslt in a null DateTime Interval\n*/\ndefine fluent function toInterval(choice Choice, Interval, Timing>):\n case\n\t when choice is DateTime then\n \tInterval[choice as DateTime, choice as DateTime]\n\t\twhen choice is Interval then\n \t\tchoice as Interval\n\t\twhen choice is Quantity then\n\t\t Interval[Patient.birthDate + (choice as Quantity),\n\t\t\t Patient.birthDate + (choice as Quantity) + 1 year)\n\t\twhen choice is Interval then\n\t\t Interval[Patient.birthDate + (choice.low as Quantity),\n\t\t\t Patient.birthDate + (choice.high as Quantity) + 1 year)\n\t\twhen choice is Timing then\n Message(null, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a Timing value is not supported') as Interval\n\t\telse\n\t\t\tnull as Interval\n\tend" + }, + { + "url": "displaySequence", + "valueInteger": 21 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isAssessmentPerformed" + }, + { + "url": "statement", + "valueString": "//This library contains functions that are based on QDM 5.6 to QICore 4.1.1 March 2023 (https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns---QICore-v4.1.1). The functions may appear similar to some QICoreCommon functions but different in that they have constraints that are relevant for measures authored by NCQA.\n\n//Assessment, Performed\ndefine fluent function isAssessmentPerformed(Obs List):\n Obs O\n where O.status in { 'final', 'amended', 'corrected' }\n and exists ( O.category ObservationCategory\n where ( ObservationCategory ) ~ \"survey\"\n )" + }, + { + "url": "displaySequence", + "valueInteger": 22 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "FHIRHelpers" + }, + { + "url": "name", + "valueString": "ToConcept" + }, + { + "url": "statement", + "valueString": "/*\n@description: Converts the given FHIR [CodeableConcept](https://hl7.org/fhir/datatypes.html#CodeableConcept) value to a CQL Concept.\n*/\ndefine function ToConcept(concept FHIR.CodeableConcept):\n if concept is null then\n null\n else\n System.Concept {\n codes: concept.coding C return ToCode(C),\n display: concept.text.value\n }" + }, + { + "url": "displaySequence", + "valueInteger": 23 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionOrder" + }, + { + "url": "statement", + "valueString": "//Intervention, Order: active and completed only \ndefine fluent function isInterventionOrder(ServiceRequest List):\n ServiceRequest S\n where S.status in { 'active', 'completed' }\n and S.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 24 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isInterventionPerformed" + }, + { + "url": "statement", + "valueString": "//Intervention, Performed\ndefine fluent function isInterventionPerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 25 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "prevalenceInterval" + }, + { + "url": "statement", + "valueString": "/*\n@description: Returns an interval representing the normalized prevalence period of a given Condition.\n@comment: Uses the ToInterval and ToAbatementInterval functions to determine the widest potential interval from\nonset to abatement as specified in the given Condition. If the condition is active, or has an abatement date the resulting \ninterval will have a closed ending boundary. Otherwise, the resulting interval will have an open ending boundary.\n*/\ndefine fluent function prevalenceInterval(condition Condition):\nif condition.clinicalStatus ~ \"active\"\n or condition.clinicalStatus ~ \"recurrence\"\n or condition.clinicalStatus ~ \"relapse\" then\n Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()]\nelse\n (end of condition.abatementInterval()) abatementDate\n return if abatementDate is null then\n Interval[start of condition.onset.toInterval(), abatementDate)\n else\n Interval[start of condition.onset.toInterval(), abatementDate]" + }, + { + "url": "displaySequence", + "valueInteger": 26 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isProcedurePerformed" + }, + { + "url": "statement", + "valueString": "//Procedure, Performed\ndefine fluent function isProcedurePerformed(Proc List):\n Proc P\n where P.status ~ 'completed'" + }, + { + "url": "displaySequence", + "valueInteger": 27 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isDeviceOrder" + }, + { + "url": "statement", + "valueString": "//Device, Order - Personal Use Devices: active and completed only\ndefine fluent function isDeviceOrder(DeviceRequest List):\n DeviceRequest D\n where D.status in { 'active', 'completed' }\n and D.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 28 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "QICoreCommon" + }, + { + "url": "name", + "valueString": "doNotPerform" + }, + { + "url": "statement", + "valueString": "/*\n@description: Returns true if the given DeviceRequest is a negation (i.e. do not perform this order)\n*/\ndefine fluent function doNotPerform(deviceRequest DeviceRequest):\n singleton from (\n deviceRequest.modifierExtension E\n where E.url = 'http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-doNotPerform'\n return E.value as Boolean\n )" + }, + { + "url": "displaySequence", + "valueInteger": 29 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isSymptom" + }, + { + "url": "statement", + "valueString": "//Symptom\ndefine fluent function isSymptom(Obs List):\n Obs O\n where O.status in { 'preliminary', 'final', 'amended', 'corrected' }" + }, + { + "url": "displaySequence", + "valueInteger": 30 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "Status" + }, + { + "url": "name", + "valueString": "isMedicationActive" + }, + { + "url": "statement", + "valueString": "//Medication, Active\ndefine fluent function isMedicationActive(MedicationRequest List):\n MedicationRequest M\n where M.status = 'active'\n and M.intent = 'order'" + }, + { + "url": "displaySequence", + "valueInteger": 31 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CumulativeMedicationDuration" + }, + { + "url": "name", + "valueString": "medicationRequestPeriod" + }, + { + "url": "statement", + "valueString": "define fluent function medicationRequestPeriod(Request \"MedicationRequest\"):\n Request R\n let\n dosage: singleton from R.dosageInstruction,\n doseAndRate: singleton from dosage.doseAndRate,\n timing: dosage.timing,\n frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency),\n period: Quantity(timing.repeat.period, timing.repeat.periodUnit),\n doseRange: doseAndRate.dose,\n doseQuantity: doseAndRate.dose,\n dose: Coalesce(end of doseRange, doseQuantity),\n dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0),\n boundsPeriod: timing.repeat.bounds as Interval,\n daysSupply: (convert R.dispenseRequest.expectedSupplyDuration to days).value,\n quantity: R.dispenseRequest.quantity,\n refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed, 0),\n startDate:\n Coalesce(\n date from start of boundsPeriod,\n date from R.authoredOn,\n date from start of R.dispenseRequest.validityPeriod\n ),\n totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills)\n return\n if startDate is not null and totalDaysSupplied is not null then\n Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ]\n else if startDate is not null and boundsPeriod.\"high\" is not null then\n Interval[startDate, date from end of boundsPeriod]\n else\n null" + }, + { + "url": "displaySequence", + "valueInteger": 32 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CumulativeMedicationDuration" + }, + { + "url": "name", + "valueString": "Quantity" + }, + { + "url": "statement", + "valueString": "/**********************************************************************/\n/* Functions in this region are copied from opioid-mme-r4 */\n/**********************************************************************/\n\ndefine function Quantity(value Decimal, unit String):\n if value is not null then\n System.Quantity { value: value, unit: unit }\n else\n null" + }, + { + "url": "displaySequence", + "valueInteger": 33 + } + ] + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-logicDefinition", + "extension": [ + { + "url": "libraryName", + "valueString": "CumulativeMedicationDuration" + }, + { + "url": "name", + "valueString": "ToDaily" + }, + { + "url": "statement", + "valueString": "/*\n Goal is to get to number of days\n Two broad approaches to the calculation:\n 1) Based on supply and frequency, calculate the number of expected days the medication will cover/has covered\n 2) Based on relevant period, determine a covered interval and calculate the length of that interval in days\nThis topic covers several use cases and illustrates how to calculate Cumulative\nMedication Duration for each type of medication resource using the supply and\nfrequency approach.\n*/\n\n/*\n For the first approach, we need to get from frequency to a frequency/day\n So we define ToDaily\n*/\n\n/*\n Calculates daily frequency given frequency within a period\n*/\ndefine function ToDaily(frequency System.Integer, period System.Quantity):\n case period.unit\n when 'h' then frequency * (24.0 / period.value)\n when 'min' then frequency * (24.0 / period.value) * 60\n when 's' then frequency * (24.0 / period.value) * 60 * 60\n when 'd' then frequency * (24.0 / period.value) / 24\n when 'wk' then frequency * (24.0 / period.value) / (24 * 7)\n when 'mo' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */\n when 'a' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */\n when 'hour' then frequency * (24.0 / period.value)\n when 'minute' then frequency * (24.0 / period.value) * 60\n when 'second' then frequency * (24.0 / period.value) * 60 * 60\n when 'day' then frequency * (24.0 / period.value) / 24\n when 'week' then frequency * (24.0 / period.value) / (24 * 7)\n when 'month' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */\n when 'year' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */\n when 'hours' then frequency * (24.0 / period.value)\n when 'minutes' then frequency * (24.0 / period.value) * 60\n when 'seconds' then frequency * (24.0 / period.value) * 60 * 60\n when 'days' then frequency * (24.0 / period.value) / 24\n when 'weeks' then frequency * (24.0 / period.value) / (24 * 7)\n when 'months' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */\n when 'years' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */\n else Message(null, true, 'CMDLogic.ToDaily.UnknownUnit', ErrorLevel, 'Unknown unit ' & period.unit)\n end" + }, + { + "url": "displaySequence", + "valueInteger": 34 + } + ] + } + ], + "name": "EffectiveDataRequirements", + "status": "active", + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "module-definition" + } + ] + }, + "relatedArtifact": [ + { + "type": "depends-on", + "display": "Library Status", + "resource": "Library/Status|1.8.000" + }, + { + "type": "depends-on", + "display": "Library QICoreCommon", + "resource": "Library/QICoreCommon|2.1.000" + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "Library/FHIRHelpers|4.4.000" + }, + { + "type": "depends-on", + "display": "Library AdultOutpatientEncounters", + "resource": "Library/AdultOutpatientEncounters|4.11.000" + }, + { + "type": "depends-on", + "display": "Library Hospice", + "resource": "Library/Hospice|6.12.000" + }, + { + "type": "depends-on", + "display": "Library AIFrailLTCF", + "resource": "Library/AdvancedIllnessandFrailty|1.16.000" + }, + { + "type": "depends-on", + "display": "Library CMD", + "resource": "Library/CumulativeMedicationDuration|4.1.000" + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": "Library/PalliativeCare|1.11.000" + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, + { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": "http://terminology.hl7.org/CodeSystem/observation-category" + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, + { + "type": "depends-on", + "display": "Value set Mammography", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" + }, + { + "type": "depends-on", + "display": "Value set Office Visit", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + }, + { + "type": "depends-on", + "display": "Value set Annual Wellness Visit", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Established Office Visit, 18 and Up", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + }, + { + "type": "depends-on", + "display": "Value set Preventive Care Services Initial Office Visit, 18 and Up", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + }, + { + "type": "depends-on", + "display": "Value set Home Healthcare Services", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + }, + { + "type": "depends-on", + "display": "Value set Virtual Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + }, + { + "type": "depends-on", + "display": "Value set Telephone Visits", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + }, + { + "type": "depends-on", + "display": "Value set Encounter Inpatient", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + }, + { + "type": "depends-on", + "display": "Value set Hospice Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + }, + { + "type": "depends-on", + "display": "Value set Hospice Care Ambulatory", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + }, + { + "type": "depends-on", + "display": "Value set Hospice Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + }, + { + "type": "depends-on", + "display": "Value set Status Post Right Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy, Unspecified Laterality", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Right", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + }, + { + "type": "depends-on", + "display": "Value set Status Post Left Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Left", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + }, + { + "type": "depends-on", + "display": "Value set History of bilateral mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" + }, + { + "type": "depends-on", + "display": "Value set Bilateral Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" + }, + { + "type": "depends-on", + "display": "Value set Frailty Device", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + }, + { + "type": "depends-on", + "display": "Value set Frailty Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1074" + }, + { + "type": "depends-on", + "display": "Value set Frailty Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1088" + }, + { + "type": "depends-on", + "display": "Value set Frailty Symptom", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1075" + }, + { + "type": "depends-on", + "display": "Value set Advanced Illness", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1082" + }, + { + "type": "depends-on", + "display": "Value set Dementia Medications", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.196.12.1510" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Diagnosis", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Encounter", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + }, + { + "type": "depends-on", + "display": "Value set Palliative Care Intervention", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "ErrorLevel", + "use": "in", + "min": 0, + "max": "1", + "type": "string" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + } + ], + "dataRequirement": [ + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ] + }, + { + "path": "value" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "98181-1", + "display": "Medical equipment used" + } + ] + }, + { + "path": "value", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + ], + "dateFilter": [ + { + "path": "effective", + "valuePeriod": { + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expression", + "valueExpression": { + "language": "text/cql-identifier", + "expression": "Measurement Period" + } + } + ] + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1075" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ] + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ] + }, + { + "path": "value" + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ] + } + ] + }, + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1088" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code", "bodySite"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1074" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1082" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + ] + }, + { + "type": "DeviceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-devicerequest" + ], + "mustSupport": [ + "code", + "status", + "status.value", + "intent", + "intent.value", + "url", + "url.value", + "value", + "authoredOn", + "authoredOn.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + ] + }, + { + "type": "MedicationRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-medicationrequest" + ], + "mustSupport": [ + "medication", + "status", + "status.value", + "intent", + "intent.value", + "dosageInstruction", + "dispenseRequest", + "dispenseRequest.expectedSupplyDuration", + "dispenseRequest.quantity", + "dispenseRequest.numberOfRepeatsAllowed", + "dispenseRequest.numberOfRepeatsAllowed.value", + "authoredOn", + "authoredOn.value", + "dispenseRequest.validityPeriod" + ], + "codeFilter": [ + { + "path": "medication", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.196.12.1510" + } + ] + } + ] + } + ], + "extension": [ + { + "id": "effective-data-requirements", + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-effectiveDataRequirements", + "valueReference": { + "reference": "#effective-data-requirements" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } + ], + "url": "https://madie.cms.gov/Measure/BreastCancerScreeningFHIR", + "identifier": [ + { + "use": "usual", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "short-name" + } + ] + }, + "system": "https://madie.cms.gov/measure/shortName", + "value": "CMS125FHIR" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-independent" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:f766afa2-f780-45d2-b224-c1bdb733fa6f" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "version-specific" + } + ] + }, + "system": "urn:ietf:rfc:3986", + "value": "urn:uuid:7c89bd23-97eb-446b-b63a-975b63503b1c" + }, + { + "use": "official", + "type": { + "coding": [ + { + "system": "http://hl7.org/fhir/us/cqfmeasures/CodeSystem/identifier-type", + "code": "publisher" + } + ] + }, + "system": "https://madie.cms.gov/measure/cmsId", + "value": "125FHIR", + "assigner": { + "display": "CMS" + } + } + ], + "version": "0.0.001", + "name": "BreastCancerScreeningFHIR", + "title": "Breast Cancer ScreeningFHIR", + "status": "active", + "experimental": false, + "date": "2024-07-09T14:53:55+00:00", + "publisher": "National Committee for Quality Assurance", + "contact": [ + { + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "description": "Percentage of women 50-74 years of age who had a mammogram to screen for breast cancer in the 27 months prior to the end of the Measurement Period", + "purpose": "UNKNOWN", + "usage": "This measure evaluates primary screening. Do not count biopsies, breast ultrasounds, or MRIs because they are not appropriate methods for primary breast cancer screening. Please note the measure may include screenings performed outside the age range of patients referenced in the initial population. Screenings that occur prior to the measurement period are valid to meet measure criteria. This eCQM is a patient-based measure. This FHIR-based measure has been derived from the QDM-based measure: CMS125v13. Please refer to the HL7 QI-Core Implementation Guide (http://hl7.org/fhir/us/qicore/STU4.1.1/) for more information on QI-Core and mapping recommendations from QDM to QI-Core 4.1.1 (http://hl7.org/fhir/us/qicore/STU4.1.1/qdm-to-qicore.html).", + "copyright": "This Physician Performance Measure (Measure) and related data specifications are owned and were developed by the National Committee for Quality Assurance (NCQA). NCQA is not responsible for any use of the Measure. NCQA makes no representations, warranties, or endorsement about the quality of any organization or physician that uses or reports performance measures and NCQA has no liability to anyone who relies on such measures or specifications. NCQA holds a copyright in the Measure. The Measure can be reproduced and distributed, without modification, for noncommercial purposes (e.g., use by healthcare providers in connection with their practices) without obtaining approval from NCQA. Commercial use is defined as the sale, licensing, or distribution of the Measure for commercial gain, or incorporation of the Measure into a product or service that is sold, licensed or distributed for commercial gain. All commercial uses or requests for modification must be approved by NCQA and are subject to a license at the discretion of NCQA. (C) 2012-2024 National Committee for Quality Assurance. All Rights Reserved. Limited proprietary coding is contained in the Measure specifications for user convenience. Users of proprietary code sets should obtain all necessary licenses from the owners of the code sets. NCQA disclaims all liability for use or accuracy of any third-party codes contained in the specifications. CPT(R) codes, descriptions and other data are copyright 2024. American Medical Association. All rights reserved. CPT is a trademark of the American Medical Association. Fee schedules, relative value units, conversion factors and/or related components are not assigned by the AMA, are not part of CPT, and the AMA is not recommending their use. The AMA does not directly or indirectly practice medicine or dispense medical services. The AMA assumes no liability for data contained or not contained herein. Applicable FARS/DFARS restrictions apply to government use. Some measure specifications contain coding from LOINC(R) (http://loinc.org). The LOINC table, LOINC codes, LOINC panels and form file, LOINC linguistic variants file, LOINC/RSNA Radiology Playbook, and LOINC/IEEE Medical Device Code Mapping Table are copyright 2004-2024 Regenstrief Institute, Inc. and the Logical Observation Identifiers Names and Codes (LOINC) Committee, and are available at no cost under the license at http://loinc.org/terms-of-use. This material contains SNOMED Clinical Terms(R) (SNOMED CT[R]) copyright 2004-2023 International Health Terminology Standards Development Organisation. ICD-10 copyright 2024 World Health Organization. All Rights Reserved. Some measures use RxNorm, a standardized nomenclature and coding for clinical drugs and drug delivery devices, which is made publicly available courtesy of the U.S. National Library of Medicine (NLM), National Institutes of Health, Department of Health and Human Services. NLM is not responsible for the measures and does not endorse or recommend this or any other product. “HL7” is the registered trademark of Health Level Seven International.", + "effectivePeriod": { + "start": "2025-01-01", + "end": "2025-12-31" + }, + "author": [ + { + "name": "National Committee for Quality Assurance", + "telecom": [ + { + "system": "url", + "value": "https://www.ncqa.org/" + } + ] + } + ], + "library": ["https://madie.cms.gov/Library/BreastCancerScreeningFHIR"], + "disclaimer": "The performance Measure is not a clinical guideline and does not establish a standard of medical care, and has not been tested for all potential applications. THE MEASURE AND SPECIFICATIONS ARE PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. Due to technical limitations, registered trademarks are indicated by (R) or [R] and unregistered trademarks are indicated by (TM) or [TM].", + "rationale": "Breast cancer is one of the most common types of cancers, accounting for 15 percent of all new cancer diagnoses in the U.S. (Noone et al., 2018). In 2015, over 3 million women were estimated to be living with breast cancer in the U.S. and it is estimated that 12 percent of women will be diagnosed with breast cancer at some point during their lifetime (Noone et al., 2018). While there are other factors that affect a woman's risk of developing breast cancer, advancing age is a primary risk factor. Breast cancer is most frequently diagnosed among women ages 55-64; the median age at diagnosis is 62 years (Noone et al., 2018). The chance of a woman being diagnosed with breast cancer in a given year increases with age. By age 40, the chances are 1 in 68; by age 50 it becomes 1 in 43; by age 60, it is 1 in 29 (American Cancer Society, 2017).", + "clinicalRecommendationStatement": "The U.S. Preventive Services Task Force (USPSTF) recommends biennial screening mammography for women aged 50-74 years (B recommendation) (USPSTF, 2016). The decision to start screening mammography in women prior to age 50 years should be an individual one. Women who place a higher value on the potential benefit than the potential harms may choose to begin biennial screening between the ages of 40 and 49 years (C recommendation) (USPSTF, 2016). The USPSTF concludes that the current evidence is insufficient to assess the balance of benefits and harms of screening mammography in women aged 75 years or older (I statement) (USPSTF, 2016). The USPSTF concludes that the current evidence is insufficient to assess the benefits and harms of digital breast tomosynthesis (DBT) as a primary screening method for breast cancer (I statement) (USPSTF, 2016). The USPSTF concludes that the current evidence is insufficient to assess the balance of benefits and harms of adjunctive screening for breast cancer using breast ultrasonography, magnetic resonance imaging, DBT, or other methods in women identified to have dense breasts on an otherwise negative screening mammogram (I statement) (USPSTF, 2016). The National Comprehensive Cancer Network (NCCN) and the American College of Radiology (ACR) recommend using conventional mammography or DBT for screening women at low, intermediate or high risk for breast cancer (NCCN, 2021) (ACR, 2017).", + "group": [ + { + "id": "64e646302ad653247b573ada", + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-scoring", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-scoring", + "code": "proportion", + "display": "Proportion" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-populationBasis", + "valueCode": "boolean" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-type", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-type", + "code": "process", + "display": "Process" + } + ] + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-rateAggregation", + "valueCode": "None" + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-improvementNotation", + "valueCodeableConcept": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-improvement-notation", + "code": "decrease", + "display": "increase" + } + ] + } + } + ], + "population": [ + { + "id": "FC061B94-3EB0-46E6-AD30-370E47E648AD", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "initial-population", + "display": "Initial Population" + } + ] + }, + "description": "Women 52-74 years of age by the end of the measurement period with a visit during the measurement period", + "criteria": { + "language": "text/cql-identifier", + "expression": "Initial Population" + } + }, + { + "id": "054B4403-E6CF-4F3C-B36B-12003F3BA268", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator", + "display": "Denominator" + } + ] + }, + "description": "Equals Initial Population", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator" + } + }, + { + "id": "209265B9-B25B-4809-BB65-DFD42207CB9D", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "denominator-exclusion", + "display": "Denominator Exclusion" + } + ] + }, + "description": "Exclude patients who are in hospice care for any part of the measurement period. Women who had a bilateral mastectomy or who have a history of a bilateral mastectomy or for whom there is evidence of a right and a left unilateral mastectomy on or before the end of the measurement period. Exclude patients 66 and older by the end of the measurement period with an indication of frailty for any part of the measurement period who also meet any of the following advanced illness criteria: - Advanced illness diagnosis during the measurement period or the year prior - OR taking dementia medications during the measurement period or the year prior Exclude patients 66 and older by the end of the measurement period who are living long term in a nursing home any time on or before the end of the measurement period. Exclude patients receiving palliative care for any part of the measurement period.", + "criteria": { + "language": "text/cql-identifier", + "expression": "Denominator Exclusions" + } + }, + { + "id": "B7745FD9-0697-40A0-A179-3056DD614C8F", + "code": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/measure-population", + "code": "numerator", + "display": "Numerator" + } + ] + }, + "description": "Women with one or more mammograms any time on or between October 1 two years prior to the measurement period and the end of the measurement period", + "criteria": { + "language": "text/cql-identifier", + "expression": "Numerator" + } + } + ] + } + ] + }, + "request": { + "method": "PUT", + "url": "Measure/BreastCancerScreeningFHIR" + } + }, + { + "fullUrl": "https://madie.cms.gov/Library/BreastCancerScreeningFHIR|0.0.001", + "resource": { + "resourceType": "Library", + "id": "BreastCancerScreeningFHIR", + "meta": { + "profile": [ + "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/computable-library-cqfm" + ] + }, + "language": "en", + "contained": [ + { + "resourceType": "Parameters", + "id": "options", + "parameter": [ + { + "name": "translatorVersion", + "valueString": "3.10.0" + }, + { + "name": "option", + "valueString": "EnableAnnotations" + }, + { + "name": "option", + "valueString": "EnableLocators" + }, + { + "name": "option", + "valueString": "DisableListDemotion" + }, + { + "name": "option", + "valueString": "DisableListPromotion" + }, + { + "name": "format", + "valueString": "XML" + }, + { + "name": "format", + "valueString": "JSON" + }, + { + "name": "analyzeDataRequirements", + "valueBoolean": true + }, + { + "name": "collapseDataRequirements", + "valueBoolean": true + }, + { + "name": "compatibilityLevel", + "valueString": "1.5" + }, + { + "name": "enableCqlOnly", + "valueBoolean": false + }, + { + "name": "errorLevel", + "valueString": "Info" + }, + { + "name": "signatureLevel", + "valueString": "None" + }, + { + "name": "validateUnits", + "valueBoolean": true + }, + { + "name": "verifyOnly", + "valueBoolean": false + } + ] + } + ], + "extension": [ + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender", + "code": "F", + "display": "Female" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "7771000", + "display": "Left (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-directReferenceCode", + "valueCoding": { + "system": "http://snomed.info/sct", + "code": "24028007", + "display": "Right (qualifier value)" + } + }, + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlOptions", + "valueReference": { + "reference": "#options" + } + }, + { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } + ], + "url": "https://madie.cms.gov/Library/BreastCancerScreeningFHIR", + "identifier": [ + { + "use": "official", + "system": "https://madie.cms.gov/login", + "value": "BreastCancerScreeningFHIR" + } + ], + "version": "0.0.001", + "name": "BreastCancerScreeningFHIR", + "title": "BreastCancerScreeningFHIR", + "status": "active", + "experimental": false, + "type": { + "coding": [ + { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "logic-library" + } + ] + }, + "date": "2024-05-16T15:11:55+00:00", + "description": "BreastCancerScreeningFHIR", + "relatedArtifact": [ + { + "type": "depends-on", + "display": "QICore model information", + "resource": "http://hl7.org/fhir/Library/QICore-ModelInfo" + }, + { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://ecqi.healthit.gov/ecqms/Library/FHIRHelpers|4.4.000" + }, + { + "type": "depends-on", + "display": "Library SDE", + "resource": "http://ecqi.healthit.gov/ecqms/Library/SupplementalDataElements|3.5.000" + }, + { + "type": "depends-on", + "display": "Library QICoreCommon", + "resource": "http://ecqi.healthit.gov/ecqms/Library/QICoreCommon|2.1.000" + }, + { + "type": "depends-on", + "display": "Library PalliativeCare", + "resource": "http://ecqi.healthit.gov/ecqms/Library/PalliativeCare|1.11.000" + }, + { + "type": "depends-on", + "display": "Code system AdministrativeGender", + "resource": "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender" + }, + { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, + { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, + { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": "http://terminology.hl7.org/CodeSystem/observation-category" + }, + { + "type": "depends-on", + "display": "Value set Status Post Left Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + }, + { + "type": "depends-on", + "display": "Value set Status Post Right Mastectomy", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Left", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy Right", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + }, + { + "type": "depends-on", + "display": "Value set Unilateral Mastectomy, Unspecified Laterality", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + }, + { + "type": "depends-on", + "display": "Value set Payer Type", + "resource": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + ], + "parameter": [ + { + "name": "Measurement Period", + "use": "in", + "min": 0, + "max": "1", + "type": "Period" + }, + { + "name": "ErrorLevel", + "use": "in", + "min": 0, + "max": "1", + "type": "string" + }, + { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "Initial Population", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Denominator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "Right Mastectomy Diagnosis", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Right Mastectomy Procedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Left Mastectomy Diagnosis", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Left Mastectomy Procedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Bilateral Mastectomy Diagnosis", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Bilateral Mastectomy Procedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "Denominator Exclusions", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "October 1 Two Years Prior to the Measurement Period", + "use": "out", + "min": 0, + "max": "1", + "type": "dateTime" + }, + { + "name": "Numerator", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, + { + "name": "SDE Ethnicity", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Payer", + "use": "out", + "min": 0, + "max": "*", + "type": "Resource" + }, + { + "name": "SDE Race", + "use": "out", + "min": 0, + "max": "1", + "type": "Resource" + }, + { + "name": "SDE Sex", + "use": "out", + "min": 0, + "max": "1", + "type": "Coding" + } + ], + "dataRequirement": [ + { + "type": "Patient", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" + ], + "mustSupport": ["ethnicity", "race"] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1001" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1240" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1025" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1023" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1016" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1089" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "status", "status.value", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1080" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": [ + "type", + "hospitalization", + "hospitalization.dischargeDisposition", + "period", + "status", + "status.value" + ], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.666.5.307" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1003" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1088" + } + ] + }, + { + "type": "Encounter", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-encounter" + ], + "mustSupport": ["type", "period", "status", "status.value"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.101.12.1090" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code", "bodySite"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1165" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1074" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.110.12.1082" + } + ] + }, + { + "type": "Condition", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" + ], + "mustSupport": ["code"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.1167" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" + } + ], + "dateFilter": [ + { + "path": "performed" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "Procedure", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" + ], + "mustSupport": ["code", "performed", "status", "status.value"], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1135" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "45755-6", + "display": "Hospice care [Minimum Data Set]" + } + ] + }, + { + "path": "value" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "value", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "98181-1", + "display": "Medical equipment used" + } + ] + }, + { + "path": "value", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + ], + "dateFilter": [ + { + "path": "effective", + "valuePeriod": { + "extension": [ + { + "url": "http://hl7.org/fhir/StructureDefinition/cqf-expression", + "valueExpression": { + "language": "text/cql-identifier", + "expression": "Measurement Period" + } + } + ] + } + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.113.12.1075" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ] + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "value", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71802-3", + "display": "Housing status" + } + ] + }, + { + "path": "value" + } + ], + "dateFilter": [ + { + "path": "effective" + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "code": [ + { + "system": "http://loinc.org", + "code": "71007-9", + "display": "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)" + } + ] + } + ] + }, + { + "type": "Observation", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" + ], + "mustSupport": [ + "code", + "effective", + "status", + "status.value", + "category" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" + } + ] + }, + { + "type": "ServiceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-servicerequest" + ], + "mustSupport": [ + "code", + "authoredOn", + "authoredOn.value", + "status", + "status.value", + "intent", + "intent.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.526.3.1584" + } + ] + }, + { + "type": "DeviceRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-devicerequest" + ], + "mustSupport": [ + "code", + "status", + "status.value", + "intent", + "intent.value", + "url", + "url.value", + "value", + "authoredOn", + "authoredOn.value" + ], + "codeFilter": [ + { + "path": "code", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.118.12.1300" + } + ] + }, + { + "type": "MedicationRequest", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-medicationrequest" + ], + "mustSupport": [ + "medication", + "status", + "status.value", + "intent", + "intent.value", + "dosageInstruction", + "dispenseRequest", + "dispenseRequest.expectedSupplyDuration", + "dispenseRequest.quantity", + "dispenseRequest.numberOfRepeatsAllowed", + "dispenseRequest.numberOfRepeatsAllowed.value", + "authoredOn", + "authoredOn.value", + "dispenseRequest.validityPeriod" + ], + "codeFilter": [ + { + "path": "medication", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.196.12.1510" + } + ] + }, + { + "type": "Coverage", + "profile": [ + "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-coverage" + ], + "mustSupport": ["type", "period"], + "codeFilter": [ + { + "path": "type", + "valueSet": "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.114222.4.11.3591" + } + ] + } + ], + "content": [ + { + "contentType": "text/cql", + "data": "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" + }, + { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1" localId="0">
   <annotation translatorVersion="3.10.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" signatureLevel="None" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:s r="491">
         <a:s>library BreastCancerScreeningFHIR version '0.0.001'</a:s>
      </a:s>
   </annotation>
   <identifier id="BreastCancerScreeningFHIR" system="http://ecqi.healthit.gov/ecqms" version="0.0.001"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localId="1" localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="206" locator="3:1-3:28" localIdentifier="QICore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="206">
               <a:s>using </a:s>
               <a:s>
                  <a:s>QICore</a:s>
               </a:s>
               <a:s> version '4.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="207" locator="5:1-5:56" localIdentifier="FHIRHelpers" path="http://ecqi.healthit.gov/ecqms/FHIRHelpers" version="4.4.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="207">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.4.000' called FHIRHelpers</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="208" locator="6:1-6:61" localIdentifier="SDE" path="http://ecqi.healthit.gov/ecqms/SupplementalDataElements" version="3.5.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="208">
               <a:s>include </a:s>
               <a:s>
                  <a:s>SupplementalDataElements</a:s>
               </a:s>
               <a:s> version '3.5.000' called SDE</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="209" locator="7:1-7:58" localIdentifier="QICoreCommon" path="http://ecqi.healthit.gov/ecqms/QICoreCommon" version="2.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="209">
               <a:s>include </a:s>
               <a:s>
                  <a:s>QICoreCommon</a:s>
               </a:s>
               <a:s> version '2.1.000' called QICoreCommon</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="210" locator="8:1-8:85" localIdentifier="AdultOutpatientEncounters" path="http://ecqi.healthit.gov/ecqms/AdultOutpatientEncounters" version="4.11.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="210">
               <a:s>include </a:s>
               <a:s>
                  <a:s>AdultOutpatientEncounters</a:s>
               </a:s>
               <a:s> version '4.11.000' called AdultOutpatientEncounters</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="211" locator="9:1-9:49" localIdentifier="Hospice" path="http://ecqi.healthit.gov/ecqms/Hospice" version="6.12.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="211">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Hospice</a:s>
               </a:s>
               <a:s> version '6.12.000' called Hospice</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="212" locator="10:1-10:46" localIdentifier="Status" path="http://ecqi.healthit.gov/ecqms/Status" version="1.8.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="212">
               <a:s>include </a:s>
               <a:s>
                  <a:s>Status</a:s>
               </a:s>
               <a:s> version '1.8.000' called Status</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="213" locator="11:1-11:63" localIdentifier="PalliativeCare" path="http://ecqi.healthit.gov/ecqms/PalliativeCare" version="1.11.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="213">
               <a:s>include </a:s>
               <a:s>
                  <a:s>PalliativeCare</a:s>
               </a:s>
               <a:s> version '1.11.000' called PalliativeCare</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="214" locator="12:1-12:71" localIdentifier="AIFrailLTCF" path="http://ecqi.healthit.gov/ecqms/AdvancedIllnessandFrailty" version="1.16.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="214">
               <a:s>include </a:s>
               <a:s>
                  <a:s>AdvancedIllnessandFrailty</a:s>
               </a:s>
               <a:s> version '1.16.000' called AIFrailLTCF</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <parameters>
      <def localId="232" locator="31:1-31:49" name="Measurement Period" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="232">
               <a:s>parameter &quot;Measurement Period&quot; </a:s>
               <a:s r="233">
                  <a:s>Interval&lt;</a:s>
                  <a:s r="234">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
            </a:s>
         </annotation>
         <parameterTypeSpecifier localId="233" locator="31:32-31:49" xsi:type="IntervalTypeSpecifier">
            <pointType localId="234" locator="31:41-31:48" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
         </parameterTypeSpecifier>
      </def>
   </parameters>
   <codeSystems>
      <def localId="215" locator="14:1-14:98" name="AdministrativeGender" id="http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="215">
               <a:s>codesystem &quot;AdministrativeGender&quot;: 'http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="216" locator="15:1-15:47" name="SNOMEDCT" id="http://snomed.info/sct" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="216">
               <a:s>codesystem &quot;SNOMEDCT&quot;: 'http://snomed.info/sct'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="217" locator="16:1-16:38" name="LOINC" id="http://loinc.org" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="217">
               <a:s>codesystem &quot;LOINC&quot;: 'http://loinc.org'</a:s>
            </a:s>
         </annotation>
      </def>
   </codeSystems>
   <valueSets>
      <def localId="218" locator="18:1-18:112" name="Bilateral Mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="218">
               <a:s>valueset &quot;Bilateral Mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="219" locator="19:1-19:123" name="History of bilateral mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="219">
               <a:s>valueset &quot;History of bilateral mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="220" locator="20:1-20:103" name="Mammography" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="220">
               <a:s>valueset &quot;Mammography&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="221" locator="21:1-21:119" name="Status Post Left Mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="221">
               <a:s>valueset &quot;Status Post Left Mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="222" locator="22:1-22:120" name="Status Post Right Mastectomy" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="222">
               <a:s>valueset &quot;Status Post Right Mastectomy&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="223" locator="23:1-23:118" name="Unilateral Mastectomy Left" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="223">
               <a:s>valueset &quot;Unilateral Mastectomy Left&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="224" locator="24:1-24:119" name="Unilateral Mastectomy Right" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="224">
               <a:s>valueset &quot;Unilateral Mastectomy Right&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="225" locator="25:1-25:137" name="Unilateral Mastectomy, Unspecified Laterality" id="http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="225">
               <a:s>valueset &quot;Unilateral Mastectomy, Unspecified Laterality&quot;: 'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071'</a:s>
            </a:s>
         </annotation>
      </def>
   </valueSets>
   <codes>
      <def localId="226" locator="27:1-27:63" name="Female" id="F" display="Female" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="226">
               <a:s>code &quot;Female&quot;: 'F' from </a:s>
               <a:s r="227">
                  <a:s>&quot;AdministrativeGender&quot;</a:s>
               </a:s>
               <a:s> display 'Female'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="227" locator="27:25-27:46" name="AdministrativeGender"/>
      </def>
      <def localId="228" locator="28:1-28:89" name="Left (qualifier value)" id="7771000" display="Left (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="228">
               <a:s>code &quot;Left (qualifier value)&quot;: '7771000' from </a:s>
               <a:s r="229">
                  <a:s>&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Left (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="229" locator="28:47-28:56" name="SNOMEDCT"/>
      </def>
      <def localId="230" locator="29:1-29:92" name="Right (qualifier value)" id="24028007" display="Right (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="230">
               <a:s>code &quot;Right (qualifier value)&quot;: '24028007' from </a:s>
               <a:s r="231">
                  <a:s>&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Right (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="231" locator="29:49-29:58" name="SNOMEDCT"/>
      </def>
   </codes>
   <contexts>
      <def localId="238" locator="33:1-33:15" name="Patient"/>
   </contexts>
   <statements>
      <def localId="236" locator="33:1-33:15" name="Patient" context="Patient">
         <expression localId="237" xsi:type="SingletonFrom">
            <operand localId="235" locator="33:1-33:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="240" locator="35:1-40:64" name="Initial Population" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="240">
               <a:s>define &quot;Initial Population&quot;:
  </a:s>
               <a:s r="241">
                  <a:s r="242">
                     <a:s r="255">
                        <a:s r="251">
                           <a:s>AgeInYearsAt(</a:s>
                           <a:s r="243">
                              <a:s>date from 
    </a:s>
                              <a:s r="244">
                                 <a:s>end of </a:s>
                                 <a:s r="245">
                                    <a:s>&quot;Measurement Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
  )</a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="254">
                           <a:s r="252">Interval[52, 74]</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    and </a:s>
                     <a:s r="256">
                        <a:s r="259">
                           <a:s r="257">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="259">
                              <a:s>gender</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="260">
                           <a:s>'female'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    and </a:s>
                  <a:s r="261">
                     <a:s>exists </a:s>
                     <a:s r="263">
                        <a:s r="262">
                           <a:s>AdultOutpatientEncounters</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="263">
                           <a:s>&quot;Qualifying Encounters&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="241" locator="36:3-40:64" xsi:type="And">
            <operand localId="242" locator="36:3-39:33" xsi:type="And">
               <operand localId="255" locator="36:3-38:23" xsi:type="In">
                  <operand localId="251" locator="36:3-38:3" precision="Year" xsi:type="CalculateAgeAt">
                     <operand localId="250" path="value" xsi:type="Property">
                        <source localId="249" path="birthDate" xsi:type="Property">
                           <source localId="248" name="Patient" xsi:type="ExpressionRef"/>
                        </source>
                     </operand>
                     <operand localId="243" locator="36:16-37:31" xsi:type="DateFrom">
                        <operand localId="244" locator="37:5-37:31" xsi:type="End">
                           <operand localId="245" locator="37:12-37:31" name="Measurement Period" xsi:type="ParameterRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="254" locator="38:8-38:23" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="252" locator="38:17-38:18" valueType="t:Integer" value="52" xsi:type="Literal"/>
                     <high localId="253" locator="38:21-38:22" valueType="t:Integer" value="74" xsi:type="Literal"/>
                  </operand>
               </operand>
               <operand localId="256" locator="39:9-39:33" xsi:type="Equal">
                  <operand localId="259" locator="39:9-39:22" path="value" xsi:type="Property">
                     <source localId="258" path="gender" xsi:type="Property">
                        <source localId="257" locator="39:9-39:15" name="Patient" xsi:type="ExpressionRef"/>
                     </source>
                  </operand>
                  <operand localId="260" locator="39:26-39:33" valueType="t:String" value="female" xsi:type="Literal"/>
               </operand>
            </operand>
            <operand localId="261" locator="40:9-40:64" xsi:type="Exists">
               <operand localId="263" locator="40:16-40:64" name="Qualifying Encounters" libraryName="AdultOutpatientEncounters" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="265" locator="42:1-43:22" name="Denominator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="265">
               <a:s>define &quot;Denominator&quot;:
  </a:s>
               <a:s r="266">
                  <a:s>&quot;Initial Population&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="266" locator="43:3-43:22" name="Initial Population" xsi:type="ExpressionRef"/>
      </def>
      <def localId="281" locator="60:1-67:96" name="Right Mastectomy Diagnosis" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="281">
               <a:s>define &quot;Right Mastectomy Diagnosis&quot;:
  </a:s>
               <a:s r="317">
                  <a:s>
                     <a:s r="282">
                        <a:s r="310">
                           <a:s>( </a:s>
                           <a:s r="310">
                              <a:s r="288">
                                 <a:s>
                                    <a:s r="283">
                                       <a:s r="286">
                                          <a:s r="286">
                                             <a:s>[Condition: </a:s>
                                             <a:s>
                                                <a:s>&quot;Status Post Right Mastectomy&quot;</a:s>
                                             </a:s>
                                             <a:s>]</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> RightMastectomyProcedure</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
    union </a:s>
                              <a:s r="309">
                                 <a:s>( </a:s>
                                 <a:s r="309">
                                    <a:s>
                                       <a:s r="289">
                                          <a:s r="292">
                                             <a:s r="292">
                                                <a:s>[Condition: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Unilateral Mastectomy, Unspecified Laterality&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> UnilateralMastectomyDiagnosis</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s r="294">
                                       <a:s>where </a:s>
                                       <a:s r="294">
                                          <a:s>exists </a:s>
                                          <a:s r="308">
                                             <a:s>( </a:s>
                                             <a:s r="308">
                                                <a:s>
                                                   <a:s r="295">
                                                      <a:s r="298">
                                                         <a:s>
                                                            <a:s>UnilateralMastectomyDiagnosis.bodySite</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s> S</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>
            </a:s>
                                                <a:s r="303">
                                                   <a:s>where </a:s>
                                                   <a:s r="303">
                                                      <a:s r="304">
                                                         <a:s>S</a:s>
                                                      </a:s>
                                                      <a:s> ~ </a:s>
                                                      <a:s r="305">
                                                         <a:s>&quot;Right (qualifier value)&quot;</a:s>
                                                      </a:s>
                                                   </a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
        )</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> RightMastectomy</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="316">
                     <a:s>where </a:s>
                     <a:s r="316">
                        <a:s r="312">
                           <a:s r="311">
                              <a:s>RightMastectomy</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="312">
                              <a:s>prevalenceInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="316"> starts on or before </a:s>
                        <a:s r="313">
                           <a:s>end of </a:s>
                           <a:s r="314">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="317" locator="61:3-67:96" xsi:type="Query">
            <source localId="282" locator="61:3-66:23" alias="RightMastectomy">
               <expression localId="310" locator="61:3-66:7" xsi:type="Union">
                  <operand localId="288" locator="61:5-61:72" xsi:type="Query">
                     <source localId="283" locator="61:5-61:72" alias="RightMastectomyProcedure">
                        <expression localId="286" locator="61:5-61:47" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="285" locator="61:17-61:46" name="Status Post Right Mastectomy" preserve="true" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                  </operand>
                  <operand localId="309" locator="62:11-66:5" xsi:type="Query">
                     <source localId="289" locator="62:13-62:102" alias="UnilateralMastectomyDiagnosis">
                        <expression localId="292" locator="62:13-62:72" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="291" locator="62:25-62:71" name="Unilateral Mastectomy, Unspecified Laterality" preserve="true" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="294" locator="63:9-65:9" xsi:type="Exists">
                        <operand localId="308" locator="63:22-65:9" xsi:type="Query">
                           <source localId="295" locator="63:24-63:63" alias="S">
                              <expression localId="298" locator="63:24-63:61" xsi:type="Query">
                                 <source localId="299" alias="$this">
                                    <expression localId="297" path="bodySite" scope="UnilateralMastectomyDiagnosis" xsi:type="Property"/>
                                 </source>
                                 <return localId="302" distinct="false">
                                    <expression localId="300" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="301" name="$this" xsi:type="AliasRef"/>
                                    </expression>
                                 </return>
                              </expression>
                           </source>
                           <where localId="303" locator="64:13-64:47" xsi:type="Equivalent">
                              <operand localId="304" locator="64:19" name="S" xsi:type="AliasRef"/>
                              <operand localId="307" xsi:type="ToConcept">
                                 <operand localId="305" locator="64:23-64:47" name="Right (qualifier value)" xsi:type="CodeRef"/>
                              </operand>
                           </where>
                        </operand>
                     </where>
                  </operand>
               </expression>
            </source>
            <where localId="316" locator="67:5-67:96" xsi:type="SameOrBefore">
               <operand localId="315" locator="67:50-67:55" xsi:type="Start">
                  <operand localId="312" locator="67:11-67:48" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="311" locator="67:11-67:25" name="RightMastectomy" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="313" locator="67:70-67:96" xsi:type="End">
                  <operand localId="314" locator="67:77-67:96" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="321" locator="69:1-71:115" name="Right Mastectomy Procedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="321">
               <a:s>define &quot;Right Mastectomy Procedure&quot;:
  </a:s>
               <a:s r="336">
                  <a:s>
                     <a:s r="322">
                        <a:s r="327">
                           <a:s>( </a:s>
                           <a:s r="327">
                              <a:s r="325">
                                 <a:s>( </a:s>
                                 <a:s r="325">
                                    <a:s>[Procedure: </a:s>
                                    <a:s>
                                       <a:s>&quot;Unilateral Mastectomy Right&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="327">
                                 <a:s>isProcedurePerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> UnilateralMastectomyRightPerformed</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="335">
                     <a:s>where </a:s>
                     <a:s r="335">
                        <a:s r="331">
                           <a:s r="330">
                              <a:s r="328">
                                 <a:s>UnilateralMastectomyRightPerformed</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="330">
                                 <a:s>performed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="331">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="335"> ends on or before </a:s>
                        <a:s r="332">
                           <a:s>end of </a:s>
                           <a:s r="333">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="336" locator="70:3-71:115" xsi:type="Query">
            <source localId="322" locator="70:3-70:112" alias="UnilateralMastectomyRightPerformed">
               <expression localId="327" locator="70:3-70:77" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="325" locator="70:5-70:50" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="324" locator="70:19-70:47" name="Unilateral Mastectomy Right" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="335" locator="71:5-71:115" xsi:type="SameOrBefore">
               <operand localId="334" locator="71:71-71:74" xsi:type="End">
                  <operand localId="331" locator="71:11-71:69" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="330" locator="71:11-71:54" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="329" path="performed" scope="UnilateralMastectomyRightPerformed" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="332" locator="71:89-71:115" xsi:type="End">
                  <operand localId="333" locator="71:96-71:115" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="341" locator="73:1-80:95" name="Left Mastectomy Diagnosis" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="341">
               <a:s>define &quot;Left Mastectomy Diagnosis&quot;:
  </a:s>
               <a:s r="375">
                  <a:s>
                     <a:s r="342">
                        <a:s r="368">
                           <a:s>( </a:s>
                           <a:s r="368">
                              <a:s r="345">
                                 <a:s>[Condition: </a:s>
                                 <a:s>
                                    <a:s>&quot;Status Post Left Mastectomy&quot;</a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                              <a:s>
    union </a:s>
                              <a:s r="367">
                                 <a:s>( </a:s>
                                 <a:s r="367">
                                    <a:s>
                                       <a:s r="347">
                                          <a:s r="350">
                                             <a:s r="350">
                                                <a:s>[Condition: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Unilateral Mastectomy, Unspecified Laterality&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> UnilateralMastectomyDiagnosis</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s r="352">
                                       <a:s>where </a:s>
                                       <a:s r="352">
                                          <a:s>exists </a:s>
                                          <a:s r="366">
                                             <a:s>( </a:s>
                                             <a:s r="366">
                                                <a:s>
                                                   <a:s r="353">
                                                      <a:s r="356">
                                                         <a:s>
                                                            <a:s>UnilateralMastectomyDiagnosis.bodySite</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s> S</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>
            </a:s>
                                                <a:s r="361">
                                                   <a:s>where </a:s>
                                                   <a:s r="361">
                                                      <a:s r="362">
                                                         <a:s>S</a:s>
                                                      </a:s>
                                                      <a:s> ~ </a:s>
                                                      <a:s r="363">
                                                         <a:s>&quot;Left (qualifier value)&quot;</a:s>
                                                      </a:s>
                                                   </a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
        )</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> LeftMastectomy</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="374">
                     <a:s>where </a:s>
                     <a:s r="374">
                        <a:s r="370">
                           <a:s r="369">
                              <a:s>LeftMastectomy</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="370">
                              <a:s>prevalenceInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="374"> starts on or before </a:s>
                        <a:s r="371">
                           <a:s>end of </a:s>
                           <a:s r="372">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="375" locator="74:3-80:95" xsi:type="Query">
            <source localId="342" locator="74:3-79:22" alias="LeftMastectomy">
               <expression localId="368" locator="74:3-79:7" xsi:type="Union">
                  <operand localId="345" locator="74:5-74:46" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="344" locator="74:17-74:45" name="Status Post Left Mastectomy" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
                  <operand localId="367" locator="75:11-79:5" xsi:type="Query">
                     <source localId="347" locator="75:13-75:102" alias="UnilateralMastectomyDiagnosis">
                        <expression localId="350" locator="75:13-75:72" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                           <codes localId="349" locator="75:25-75:71" name="Unilateral Mastectomy, Unspecified Laterality" preserve="true" xsi:type="ValueSetRef"/>
                        </expression>
                     </source>
                     <where localId="352" locator="76:9-78:9" xsi:type="Exists">
                        <operand localId="366" locator="76:22-78:9" xsi:type="Query">
                           <source localId="353" locator="76:24-76:63" alias="S">
                              <expression localId="356" locator="76:24-76:61" xsi:type="Query">
                                 <source localId="357" alias="$this">
                                    <expression localId="355" path="bodySite" scope="UnilateralMastectomyDiagnosis" xsi:type="Property"/>
                                 </source>
                                 <return localId="360" distinct="false">
                                    <expression localId="358" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="359" name="$this" xsi:type="AliasRef"/>
                                    </expression>
                                 </return>
                              </expression>
                           </source>
                           <where localId="361" locator="77:13-77:46" xsi:type="Equivalent">
                              <operand localId="362" locator="77:19" name="S" xsi:type="AliasRef"/>
                              <operand localId="365" xsi:type="ToConcept">
                                 <operand localId="363" locator="77:23-77:46" name="Left (qualifier value)" xsi:type="CodeRef"/>
                              </operand>
                           </where>
                        </operand>
                     </where>
                  </operand>
               </expression>
            </source>
            <where localId="374" locator="80:5-80:95" xsi:type="SameOrBefore">
               <operand localId="373" locator="80:49-80:54" xsi:type="Start">
                  <operand localId="370" locator="80:11-80:47" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="369" locator="80:11-80:24" name="LeftMastectomy" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="371" locator="80:69-80:95" xsi:type="End">
                  <operand localId="372" locator="80:76-80:95" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="379" locator="82:1-84:114" name="Left Mastectomy Procedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="379">
               <a:s>define &quot;Left Mastectomy Procedure&quot;:
  </a:s>
               <a:s r="394">
                  <a:s>
                     <a:s r="380">
                        <a:s r="385">
                           <a:s>( </a:s>
                           <a:s r="385">
                              <a:s r="383">
                                 <a:s>( </a:s>
                                 <a:s r="383">
                                    <a:s>[Procedure: </a:s>
                                    <a:s>
                                       <a:s>&quot;Unilateral Mastectomy Left&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="385">
                                 <a:s>isProcedurePerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> UnilateralMastectomyLeftPerformed</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="393">
                     <a:s>where </a:s>
                     <a:s r="393">
                        <a:s r="389">
                           <a:s r="388">
                              <a:s r="386">
                                 <a:s>UnilateralMastectomyLeftPerformed</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="388">
                                 <a:s>performed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="389">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="393"> ends on or before </a:s>
                        <a:s r="390">
                           <a:s>end of </a:s>
                           <a:s r="391">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="394" locator="83:3-84:114" xsi:type="Query">
            <source localId="380" locator="83:3-83:110" alias="UnilateralMastectomyLeftPerformed">
               <expression localId="385" locator="83:3-83:76" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="383" locator="83:5-83:49" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="382" locator="83:19-83:46" name="Unilateral Mastectomy Left" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="393" locator="84:5-84:114" xsi:type="SameOrBefore">
               <operand localId="392" locator="84:70-84:73" xsi:type="End">
                  <operand localId="389" locator="84:11-84:68" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="388" locator="84:11-84:53" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="387" path="performed" scope="UnilateralMastectomyLeftPerformed" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="390" locator="84:88-84:114" xsi:type="End">
                  <operand localId="391" locator="84:95-84:114" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="398" locator="86:1-88:107" name="Bilateral Mastectomy Diagnosis" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="398">
               <a:s>define &quot;Bilateral Mastectomy Diagnosis&quot;:
  </a:s>
               <a:s r="410">
                  <a:s>
                     <a:s r="399">
                        <a:s r="402">
                           <a:s r="402">
                              <a:s>[Condition: </a:s>
                              <a:s>
                                 <a:s>&quot;History of bilateral mastectomy&quot;</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> BilateralMastectomyHistory</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="409">
                     <a:s>where </a:s>
                     <a:s r="409">
                        <a:s r="405">
                           <a:s r="404">
                              <a:s>BilateralMastectomyHistory</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="405">
                              <a:s>prevalenceInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="409"> starts on or before </a:s>
                        <a:s r="406">
                           <a:s>end of </a:s>
                           <a:s r="407">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="410" locator="87:3-88:107" xsi:type="Query">
            <source localId="399" locator="87:3-87:75" alias="BilateralMastectomyHistory">
               <expression localId="402" locator="87:3-87:48" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                  <codes localId="401" locator="87:15-87:47" name="History of bilateral mastectomy" preserve="true" xsi:type="ValueSetRef"/>
               </expression>
            </source>
            <where localId="409" locator="88:5-88:107" xsi:type="SameOrBefore">
               <operand localId="408" locator="88:61-88:66" xsi:type="Start">
                  <operand localId="405" locator="88:11-88:59" name="prevalenceInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="404" locator="88:11-88:36" name="BilateralMastectomyHistory" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="406" locator="88:81-88:107" xsi:type="End">
                  <operand localId="407" locator="88:88-88:107" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="414" locator="90:1-92:109" name="Bilateral Mastectomy Procedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="414">
               <a:s>define &quot;Bilateral Mastectomy Procedure&quot;:
  </a:s>
               <a:s r="429">
                  <a:s>
                     <a:s r="415">
                        <a:s r="420">
                           <a:s>( </a:s>
                           <a:s r="420">
                              <a:s r="418">
                                 <a:s>( </a:s>
                                 <a:s r="418">
                                    <a:s>[Procedure: </a:s>
                                    <a:s>
                                       <a:s>&quot;Bilateral Mastectomy&quot;</a:s>
                                    </a:s>
                                    <a:s>]</a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="420">
                                 <a:s>isProcedurePerformed ( )</a:s>
                              </a:s>
                           </a:s>
                           <a:s> )</a:s>
                        </a:s>
                        <a:s> BilateralMastectomyPerformed</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="428">
                     <a:s>where </a:s>
                     <a:s r="428">
                        <a:s r="424">
                           <a:s r="423">
                              <a:s r="421">
                                 <a:s>BilateralMastectomyPerformed</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="423">
                                 <a:s>performed</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="424">
                              <a:s>toInterval ( )</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="428"> ends on or before </a:s>
                        <a:s r="425">
                           <a:s>end of </a:s>
                           <a:s r="426">
                              <a:s>&quot;Measurement Period&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="429" locator="91:3-92:109" xsi:type="Query">
            <source localId="415" locator="91:3-91:99" alias="BilateralMastectomyPerformed">
               <expression localId="420" locator="91:3-91:70" name="isProcedurePerformed" libraryName="Status" xsi:type="FunctionRef">
                  <operand localId="418" locator="91:5-91:43" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                     <codes localId="417" locator="91:19-91:40" name="Bilateral Mastectomy" preserve="true" xsi:type="ValueSetRef"/>
                  </operand>
               </expression>
            </source>
            <where localId="428" locator="92:5-92:109" xsi:type="SameOrBefore">
               <operand localId="427" locator="92:65-92:68" xsi:type="End">
                  <operand localId="424" locator="92:11-92:63" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                     <operand localId="423" locator="92:11-92:48" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="422" path="performed" scope="BilateralMastectomyPerformed" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="425" locator="92:83-92:109" xsi:type="End">
                  <operand localId="426" locator="92:90-92:109" name="Measurement Period" xsi:type="ParameterRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="268" locator="45:1-58:69" name="Denominator Exclusions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="268">
               <a:s>define &quot;Denominator Exclusions&quot;:
  </a:s>
               <a:s r="269">
                  <a:s r="270">
                     <a:s r="271">
                        <a:s r="272">
                           <a:s r="273">
                              <a:s r="274">
                                 <a:s r="276">
                                    <a:s r="275">
                                       <a:s>Hospice</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="276">
                                       <a:s>&quot;Has Hospice Services&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    or </a:s>
                                 <a:s r="277">
                                    <a:s>( </a:s>
                                    <a:s r="277">
                                       <a:s r="278">
                                          <a:s>( </a:s>
                                          <a:s r="278">
                                             <a:s r="279">
                                                <a:s>exists </a:s>
                                                <a:s r="318">
                                                   <a:s>( </a:s>
                                                   <a:s r="318">
                                                      <a:s>&quot;Right Mastectomy Diagnosis&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
          or </a:s>
                                             <a:s r="319">
                                                <a:s>exists </a:s>
                                                <a:s r="337">
                                                   <a:s>( </a:s>
                                                   <a:s r="337">
                                                      <a:s>&quot;Right Mastectomy Procedure&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
      )</a:s>
                                       </a:s>
                                       <a:s>
        and </a:s>
                                       <a:s r="338">
                                          <a:s>( </a:s>
                                          <a:s r="338">
                                             <a:s r="339">
                                                <a:s>exists </a:s>
                                                <a:s r="376">
                                                   <a:s>( </a:s>
                                                   <a:s r="376">
                                                      <a:s>&quot;Left Mastectomy Diagnosis&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
            or </a:s>
                                             <a:s r="377">
                                                <a:s>exists </a:s>
                                                <a:s r="395">
                                                   <a:s>( </a:s>
                                                   <a:s r="395">
                                                      <a:s>&quot;Left Mastectomy Procedure&quot;</a:s>
                                                   </a:s>
                                                   <a:s> )</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
        )</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
    )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
    or </a:s>
                              <a:s r="396">
                                 <a:s>exists </a:s>
                                 <a:s r="411">
                                    <a:s>&quot;Bilateral Mastectomy Diagnosis&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    or </a:s>
                           <a:s r="412">
                              <a:s>exists </a:s>
                              <a:s r="430">
                                 <a:s>&quot;Bilateral Mastectomy Procedure&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    or </a:s>
                        <a:s r="432">
                           <a:s r="431">
                              <a:s>AIFrailLTCF</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="432">
                              <a:s>&quot;Is Age 66 or Older with Advanced Illness and Frailty&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="434">
                        <a:s r="433">
                           <a:s>AIFrailLTCF</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="434">
                           <a:s>&quot;Is Age 66 or Older Living Long Term in a Nursing Home&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    or </a:s>
                  <a:s r="436">
                     <a:s r="435">
                        <a:s>PalliativeCare</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="436">
                        <a:s>&quot;Has Palliative Care in the Measurement Period&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="269" locator="46:3-58:69" xsi:type="Or">
            <operand localId="270" locator="46:3-57:74" xsi:type="Or">
               <operand localId="271" locator="46:3-56:73" xsi:type="Or">
                  <operand localId="272" locator="46:3-55:46" xsi:type="Or">
                     <operand localId="273" locator="46:3-54:46" xsi:type="Or">
                        <operand localId="274" locator="46:3-53:5" xsi:type="Or">
                           <operand localId="276" locator="46:3-46:32" name="Has Hospice Services" libraryName="Hospice" xsi:type="ExpressionRef"/>
                           <operand localId="277" locator="47:8-53:5" xsi:type="And">
                              <operand localId="278" locator="47:10-49:7" xsi:type="Or">
                                 <operand localId="279" locator="47:12-47:50" xsi:type="Exists">
                                    <operand localId="318" locator="47:19-47:50" name="Right Mastectomy Diagnosis" xsi:type="ExpressionRef"/>
                                 </operand>
                                 <operand localId="319" locator="48:14-48:52" xsi:type="Exists">
                                    <operand localId="337" locator="48:21-48:52" name="Right Mastectomy Procedure" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                              <operand localId="338" locator="50:13-52:9" xsi:type="Or">
                                 <operand localId="339" locator="50:15-50:52" xsi:type="Exists">
                                    <operand localId="376" locator="50:22-50:52" name="Left Mastectomy Diagnosis" xsi:type="ExpressionRef"/>
                                 </operand>
                                 <operand localId="377" locator="51:16-51:53" xsi:type="Exists">
                                    <operand localId="395" locator="51:23-51:53" name="Left Mastectomy Procedure" xsi:type="ExpressionRef"/>
                                 </operand>
                              </operand>
                           </operand>
                        </operand>
                        <operand localId="396" locator="54:8-54:46" xsi:type="Exists">
                           <operand localId="411" locator="54:15-54:46" name="Bilateral Mastectomy Diagnosis" xsi:type="ExpressionRef"/>
                        </operand>
                     </operand>
                     <operand localId="412" locator="55:8-55:46" xsi:type="Exists">
                        <operand localId="430" locator="55:15-55:46" name="Bilateral Mastectomy Procedure" xsi:type="ExpressionRef"/>
                     </operand>
                  </operand>
                  <operand localId="432" locator="56:8-56:73" name="Is Age 66 or Older with Advanced Illness and Frailty" libraryName="AIFrailLTCF" xsi:type="ExpressionRef"/>
               </operand>
               <operand localId="434" locator="57:8-57:74" name="Is Age 66 or Older Living Long Term in a Nursing Home" libraryName="AIFrailLTCF" xsi:type="ExpressionRef"/>
            </operand>
            <operand localId="436" locator="58:8-58:69" name="Has Palliative Care in the Measurement Period" libraryName="PalliativeCare" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="451" locator="99:1-100:79" name="October 1 Two Years Prior to the Measurement Period" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="451">
               <a:s>define &quot;October 1 Two Years Prior to the Measurement Period&quot;:
  </a:s>
               <a:s r="468">
                  <a:s>DateTime(</a:s>
                  <a:s r="452">
                     <a:s>(</a:s>
                     <a:s r="452">
                        <a:s r="453">
                           <a:s>year from </a:s>
                           <a:s r="454">
                              <a:s>start of </a:s>
                              <a:s r="455">
                                 <a:s>&quot;Measurement Period&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s r="456"> - 2</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
                  <a:s r="457">, 10, 1, 0, 0, 0, 0, 0)</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="468" locator="100:3-100:79" xsi:type="DateTime">
            <year localId="452" locator="100:12-100:56" xsi:type="Subtract">
               <operand localId="453" locator="100:13-100:51" precision="Year" xsi:type="DateTimeComponentFrom">
                  <operand localId="454" locator="100:23-100:51" xsi:type="Start">
                     <operand localId="455" locator="100:32-100:51" name="Measurement Period" xsi:type="ParameterRef"/>
                  </operand>
               </operand>
               <operand localId="456" locator="100:55" valueType="t:Integer" value="2" xsi:type="Literal"/>
            </year>
            <month localId="457" locator="100:59-100:60" valueType="t:Integer" value="10" xsi:type="Literal"/>
            <day localId="458" locator="100:63" valueType="t:Integer" value="1" xsi:type="Literal"/>
            <hour localId="459" locator="100:66" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <minute localId="460" locator="100:69" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <second localId="461" locator="100:72" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <millisecond localId="462" locator="100:75" valueType="t:Integer" value="0" xsi:type="Literal"/>
            <timezoneOffset localId="470" xsi:type="ToDecimal">
               <operand localId="463" locator="100:78" valueType="t:Integer" value="0" xsi:type="Literal"/>
            </timezoneOffset>
         </expression>
      </def>
      <def localId="438" locator="94:1-97:3" name="Numerator" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="438">
               <a:s>define &quot;Numerator&quot;:
  </a:s>
               <a:s r="439">
                  <a:s>exists </a:s>
                  <a:s r="477">
                     <a:s>( </a:s>
                     <a:s r="477">
                        <a:s>
                           <a:s r="440">
                              <a:s r="445">
                                 <a:s>( </a:s>
                                 <a:s r="445">
                                    <a:s r="443">
                                       <a:s>( </a:s>
                                       <a:s r="443">
                                          <a:s>[Observation: </a:s>
                                          <a:s>
                                             <a:s>&quot;Mammography&quot;</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                       <a:s> )</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="445">
                                       <a:s>isDiagnosticStudyPerformed ( )</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> )</a:s>
                              </a:s>
                              <a:s> Mammogram</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="476">
                           <a:s>where </a:s>
                           <a:s r="476">
                              <a:s r="449">
                                 <a:s r="448">
                                    <a:s r="446">
                                       <a:s>Mammogram</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="448">
                                       <a:s>effective</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="449">
                                    <a:s>toInterval ( )</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="476"> ends during day of </a:s>
                              <a:s r="474">
                                 <a:s>Interval[</a:s>
                                 <a:s r="471">
                                    <a:s>&quot;October 1 Two Years Prior to the Measurement Period&quot;</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="472">
                                    <a:s>end of </a:s>
                                    <a:s r="473">
                                       <a:s>&quot;Measurement Period&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="439" locator="95:3-97:3" xsi:type="Exists">
            <operand localId="477" locator="95:10-97:3" xsi:type="Query">
               <source localId="440" locator="95:12-95:88" alias="Mammogram">
                  <expression localId="445" locator="95:12-95:78" name="isDiagnosticStudyPerformed" libraryName="Status" xsi:type="FunctionRef">
                     <operand localId="443" locator="95:14-95:45" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation" codeProperty="code" codeComparator="in" xsi:type="Retrieve">
                        <codes localId="442" locator="95:30-95:42" name="Mammography" preserve="true" xsi:type="ValueSetRef"/>
                     </operand>
                  </expression>
               </source>
               <where localId="476" locator="96:7-96:158" precision="Day" xsi:type="In">
                  <operand localId="475" locator="96:48-96:51" xsi:type="End">
                     <operand localId="449" locator="96:13-96:46" name="toInterval" libraryName="QICoreCommon" xsi:type="FunctionRef">
                        <operand localId="448" locator="96:13-96:31" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="447" path="effective" scope="Mammogram" xsi:type="Property"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="474" locator="96:67-96:158" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="471" locator="96:76-96:128" name="October 1 Two Years Prior to the Measurement Period" xsi:type="ExpressionRef"/>
                     <high localId="472" locator="96:131-96:157" xsi:type="End">
                        <operand localId="473" locator="96:138-96:157" name="Measurement Period" xsi:type="ParameterRef"/>
                     </high>
                  </operand>
               </where>
            </operand>
         </expression>
      </def>
      <def localId="479" locator="102:1-103:21" name="SDE Ethnicity" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="479">
               <a:s>define &quot;SDE Ethnicity&quot;:
  </a:s>
               <a:s r="481">
                  <a:s r="480">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="481">
                     <a:s>&quot;SDE Ethnicity&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="481" locator="103:3-103:21" name="SDE Ethnicity" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="483" locator="105:1-106:17" name="SDE Payer" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="483">
               <a:s>define &quot;SDE Payer&quot;:
  </a:s>
               <a:s r="485">
                  <a:s r="484">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="485">
                     <a:s>&quot;SDE Payer&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="485" locator="106:3-106:17" name="SDE Payer" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="487" locator="108:1-109:16" name="SDE Race" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="487">
               <a:s>define &quot;SDE Race&quot;:
  </a:s>
               <a:s r="489">
                  <a:s r="488">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="489">
                     <a:s>&quot;SDE Race&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="489" locator="109:3-109:16" name="SDE Race" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="491" locator="111:1-112:15" name="SDE Sex" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="491">
               <a:s>define &quot;SDE Sex&quot;:
  </a:s>
               <a:s r="493">
                  <a:s r="492">
                     <a:s>SDE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="493">
                     <a:s>&quot;SDE Sex&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="493" locator="112:3-112:15" name="SDE Sex" libraryName="SDE" xsi:type="ExpressionRef"/>
      </def>
   </statements>
</library>
" + }, + { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "localId" : "0",
      "annotation" : [ {
         "translatorVersion" : "3.10.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "signatureLevel" : "None",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "s" : {
            "r" : "491",
            "s" : [ {
               "value" : [ "","library BreastCancerScreeningFHIR version '0.0.001'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "BreastCancerScreeningFHIR",
         "system" : "http://ecqi.healthit.gov/ecqms",
         "version" : "0.0.001"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localId" : "1",
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "206",
            "locator" : "3:1-3:28",
            "localIdentifier" : "QICore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "206",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICore" ]
                     } ]
                  }, {
                     "value" : [ " version '4.1.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "207",
            "locator" : "5:1-5:56",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://ecqi.healthit.gov/ecqms/FHIRHelpers",
            "version" : "4.4.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "207",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.4.000'"," called ","FHIRHelpers" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "208",
            "locator" : "6:1-6:61",
            "localIdentifier" : "SDE",
            "path" : "http://ecqi.healthit.gov/ecqms/SupplementalDataElements",
            "version" : "3.5.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "208",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "SupplementalDataElements" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.5.000'"," called ","SDE" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "209",
            "locator" : "7:1-7:58",
            "localIdentifier" : "QICoreCommon",
            "path" : "http://ecqi.healthit.gov/ecqms/QICoreCommon",
            "version" : "2.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "209",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "QICoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'2.1.000'"," called ","QICoreCommon" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "210",
            "locator" : "8:1-8:85",
            "localIdentifier" : "AdultOutpatientEncounters",
            "path" : "http://ecqi.healthit.gov/ecqms/AdultOutpatientEncounters",
            "version" : "4.11.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "210",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "AdultOutpatientEncounters" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.11.000'"," called ","AdultOutpatientEncounters" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "211",
            "locator" : "9:1-9:49",
            "localIdentifier" : "Hospice",
            "path" : "http://ecqi.healthit.gov/ecqms/Hospice",
            "version" : "6.12.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "211",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Hospice" ]
                     } ]
                  }, {
                     "value" : [ " version ","'6.12.000'"," called ","Hospice" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "212",
            "locator" : "10:1-10:46",
            "localIdentifier" : "Status",
            "path" : "http://ecqi.healthit.gov/ecqms/Status",
            "version" : "1.8.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "212",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "Status" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.8.000'"," called ","Status" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "213",
            "locator" : "11:1-11:63",
            "localIdentifier" : "PalliativeCare",
            "path" : "http://ecqi.healthit.gov/ecqms/PalliativeCare",
            "version" : "1.11.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "213",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "PalliativeCare" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.11.000'"," called ","PalliativeCare" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "214",
            "locator" : "12:1-12:71",
            "localIdentifier" : "AIFrailLTCF",
            "path" : "http://ecqi.healthit.gov/ecqms/AdvancedIllnessandFrailty",
            "version" : "1.16.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "214",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "AdvancedIllnessandFrailty" ]
                     } ]
                  }, {
                     "value" : [ " version ","'1.16.000'"," called ","AIFrailLTCF" ]
                  } ]
               }
            } ]
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "232",
            "locator" : "31:1-31:49",
            "name" : "Measurement Period",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "232",
                  "s" : [ {
                     "value" : [ "","parameter ","\"Measurement Period\""," " ]
                  }, {
                     "r" : "233",
                     "s" : [ {
                        "value" : [ "Interval<" ]
                     }, {
                        "r" : "234",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  } ]
               }
            } ],
            "parameterTypeSpecifier" : {
               "localId" : "233",
               "locator" : "31:32-31:49",
               "type" : "IntervalTypeSpecifier",
               "pointType" : {
                  "localId" : "234",
                  "locator" : "31:41-31:48",
                  "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                  "type" : "NamedTypeSpecifier"
               }
            }
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "215",
            "locator" : "14:1-14:98",
            "name" : "AdministrativeGender",
            "id" : "http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "215",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"AdministrativeGender\"",": ","'http://terminology.hl7.org/CodeSystem/v3-AdministrativeGender'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "216",
            "locator" : "15:1-15:47",
            "name" : "SNOMEDCT",
            "id" : "http://snomed.info/sct",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "216",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"SNOMEDCT\"",": ","'http://snomed.info/sct'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "217",
            "locator" : "16:1-16:38",
            "name" : "LOINC",
            "id" : "http://loinc.org",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "217",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"LOINC\"",": ","'http://loinc.org'" ]
                  } ]
               }
            } ]
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "218",
            "locator" : "18:1-18:112",
            "name" : "Bilateral Mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "218",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Bilateral Mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1005'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "219",
            "locator" : "19:1-19:123",
            "name" : "History of bilateral mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "219",
                  "s" : [ {
                     "value" : [ "","valueset ","\"History of bilateral mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1068'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "220",
            "locator" : "20:1-20:103",
            "name" : "Mammography",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "220",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Mammography\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.108.12.1018'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "221",
            "locator" : "21:1-21:119",
            "name" : "Status Post Left Mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "221",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Status Post Left Mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1069'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "222",
            "locator" : "22:1-22:120",
            "name" : "Status Post Right Mastectomy",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "222",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Status Post Right Mastectomy\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1070'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "223",
            "locator" : "23:1-23:118",
            "name" : "Unilateral Mastectomy Left",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "223",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Unilateral Mastectomy Left\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1133'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "224",
            "locator" : "24:1-24:119",
            "name" : "Unilateral Mastectomy Right",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "224",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Unilateral Mastectomy Right\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1134'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         }, {
            "localId" : "225",
            "locator" : "25:1-25:137",
            "name" : "Unilateral Mastectomy, Unspecified Laterality",
            "id" : "http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "225",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Unilateral Mastectomy, Unspecified Laterality\"",": ","'http://cts.nlm.nih.gov/fhir/ValueSet/2.16.840.1.113883.3.464.1003.198.12.1071'" ]
                  } ]
               }
            } ],
            "codeSystem" : [ ]
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "226",
            "locator" : "27:1-27:63",
            "name" : "Female",
            "id" : "F",
            "display" : "Female",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "226",
                  "s" : [ {
                     "value" : [ "","code ","\"Female\"",": ","'F'"," from " ]
                  }, {
                     "r" : "227",
                     "s" : [ {
                        "value" : [ "\"AdministrativeGender\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Female'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "227",
               "locator" : "27:25-27:46",
               "name" : "AdministrativeGender"
            }
         }, {
            "localId" : "228",
            "locator" : "28:1-28:89",
            "name" : "Left (qualifier value)",
            "id" : "7771000",
            "display" : "Left (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "228",
                  "s" : [ {
                     "value" : [ "","code ","\"Left (qualifier value)\"",": ","'7771000'"," from " ]
                  }, {
                     "r" : "229",
                     "s" : [ {
                        "value" : [ "\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Left (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "229",
               "locator" : "28:47-28:56",
               "name" : "SNOMEDCT"
            }
         }, {
            "localId" : "230",
            "locator" : "29:1-29:92",
            "name" : "Right (qualifier value)",
            "id" : "24028007",
            "display" : "Right (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "230",
                  "s" : [ {
                     "value" : [ "","code ","\"Right (qualifier value)\"",": ","'24028007'"," from " ]
                  }, {
                     "r" : "231",
                     "s" : [ {
                        "value" : [ "\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Right (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "231",
               "locator" : "29:49-29:58",
               "name" : "SNOMEDCT"
            }
         } ]
      },
      "contexts" : {
         "def" : [ {
            "localId" : "238",
            "locator" : "33:1-33:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "localId" : "236",
            "locator" : "33:1-33:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "localId" : "237",
               "type" : "SingletonFrom",
               "signature" : [ ],
               "operand" : {
                  "localId" : "235",
                  "locator" : "33:1-33:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-patient",
                  "type" : "Retrieve",
                  "include" : [ ],
                  "codeFilter" : [ ],
                  "dateFilter" : [ ],
                  "otherFilter" : [ ]
               }
            }
         }, {
            "localId" : "240",
            "locator" : "35:1-40:64",
            "name" : "Initial Population",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "240",
                  "s" : [ {
                     "value" : [ "","define ","\"Initial Population\"",":\n  " ]
                  }, {
                     "r" : "241",
                     "s" : [ {
                        "r" : "242",
                        "s" : [ {
                           "r" : "255",
                           "s" : [ {
                              "r" : "251",
                              "s" : [ {
                                 "value" : [ "AgeInYearsAt","(" ]
                              }, {
                                 "r" : "243",
                                 "s" : [ {
                                    "value" : [ "date from \n    " ]
                                 }, {
                                    "r" : "244",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "245",
                                       "s" : [ {
                                          "value" : [ "\"Measurement Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n  )" ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "254",
                              "s" : [ {
                                 "r" : "252",
                                 "value" : [ "Interval[","52",", ","74","]" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    and " ]
                        }, {
                           "r" : "256",
                           "s" : [ {
                              "r" : "259",
                              "s" : [ {
                                 "r" : "257",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "259",
                                 "s" : [ {
                                    "value" : [ "gender" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "260",
                              "s" : [ {
                                 "value" : [ "'female'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    and " ]
                     }, {
                        "r" : "261",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "263",
                           "s" : [ {
                              "r" : "262",
                              "s" : [ {
                                 "value" : [ "AdultOutpatientEncounters" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "263",
                              "s" : [ {
                                 "value" : [ "\"Qualifying Encounters\"" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "241",
               "locator" : "36:3-40:64",
               "type" : "And",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "242",
                  "locator" : "36:3-39:33",
                  "type" : "And",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "255",
                     "locator" : "36:3-38:23",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "251",
                        "locator" : "36:3-38:3",
                        "precision" : "Year",
                        "type" : "CalculateAgeAt",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "250",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "249",
                              "path" : "birthDate",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "248",
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           }
                        }, {
                           "localId" : "243",
                           "locator" : "36:16-37:31",
                           "type" : "DateFrom",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "244",
                              "locator" : "37:5-37:31",
                              "type" : "End",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "245",
                                 "locator" : "37:12-37:31",
                                 "name" : "Measurement Period",
                                 "type" : "ParameterRef"
                              }
                           }
                        } ]
                     }, {
                        "localId" : "254",
                        "locator" : "38:8-38:23",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "252",
                           "locator" : "38:17-38:18",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "52",
                           "type" : "Literal"
                        },
                        "high" : {
                           "localId" : "253",
                           "locator" : "38:21-38:22",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "74",
                           "type" : "Literal"
                        }
                     } ]
                  }, {
                     "localId" : "256",
                     "locator" : "39:9-39:33",
                     "type" : "Equal",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "259",
                        "locator" : "39:9-39:22",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "258",
                           "path" : "gender",
                           "type" : "Property",
                           "source" : {
                              "localId" : "257",
                              "locator" : "39:9-39:15",
                              "name" : "Patient",
                              "type" : "ExpressionRef"
                           }
                        }
                     }, {
                        "localId" : "260",
                        "locator" : "39:26-39:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "female",
                        "type" : "Literal"
                     } ]
                  } ]
               }, {
                  "localId" : "261",
                  "locator" : "40:9-40:64",
                  "type" : "Exists",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "263",
                     "locator" : "40:16-40:64",
                     "name" : "Qualifying Encounters",
                     "libraryName" : "AdultOutpatientEncounters",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "265",
            "locator" : "42:1-43:22",
            "name" : "Denominator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "265",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator\"",":\n  " ]
                  }, {
                     "r" : "266",
                     "s" : [ {
                        "value" : [ "\"Initial Population\"" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "266",
               "locator" : "43:3-43:22",
               "name" : "Initial Population",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "281",
            "locator" : "60:1-67:96",
            "name" : "Right Mastectomy Diagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "281",
                  "s" : [ {
                     "value" : [ "","define ","\"Right Mastectomy Diagnosis\"",":\n  " ]
                  }, {
                     "r" : "317",
                     "s" : [ {
                        "s" : [ {
                           "r" : "282",
                           "s" : [ {
                              "r" : "310",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "310",
                                 "s" : [ {
                                    "r" : "288",
                                    "s" : [ {
                                       "s" : [ {
                                          "r" : "283",
                                          "s" : [ {
                                             "r" : "286",
                                             "s" : [ {
                                                "r" : "286",
                                                "s" : [ {
                                                   "value" : [ "[","Condition",": " ]
                                                }, {
                                                   "s" : [ {
                                                      "value" : [ "\"Status Post Right Mastectomy\"" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "]" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","RightMastectomyProcedure" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    union " ]
                                 }, {
                                    "r" : "309",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "309",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "289",
                                             "s" : [ {
                                                "r" : "292",
                                                "s" : [ {
                                                   "r" : "292",
                                                   "s" : [ {
                                                      "value" : [ "[","Condition",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Unilateral Mastectomy, Unspecified Laterality\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","UnilateralMastectomyDiagnosis" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "r" : "294",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "294",
                                             "s" : [ {
                                                "value" : [ "exists " ]
                                             }, {
                                                "r" : "308",
                                                "s" : [ {
                                                   "value" : [ "( " ]
                                                }, {
                                                   "r" : "308",
                                                   "s" : [ {
                                                      "s" : [ {
                                                         "r" : "295",
                                                         "s" : [ {
                                                            "r" : "298",
                                                            "s" : [ {
                                                               "s" : [ {
                                                                  "value" : [ "UnilateralMastectomyDiagnosis",".","bodySite" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","S" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n            " ]
                                                   }, {
                                                      "r" : "303",
                                                      "s" : [ {
                                                         "value" : [ "where " ]
                                                      }, {
                                                         "r" : "303",
                                                         "s" : [ {
                                                            "r" : "304",
                                                            "s" : [ {
                                                               "value" : [ "S" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","~"," " ]
                                                         }, {
                                                            "r" : "305",
                                                            "s" : [ {
                                                               "value" : [ "\"Right (qualifier value)\"" ]
                                                            } ]
                                                         } ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n        )" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","RightMastectomy" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "316",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "316",
                           "s" : [ {
                              "r" : "312",
                              "s" : [ {
                                 "r" : "311",
                                 "s" : [ {
                                    "value" : [ "RightMastectomy" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "312",
                                 "s" : [ {
                                    "value" : [ "prevalenceInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "316",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "313",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "314",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "317",
               "locator" : "61:3-67:96",
               "type" : "Query",
               "source" : [ {
                  "localId" : "282",
                  "locator" : "61:3-66:23",
                  "alias" : "RightMastectomy",
                  "expression" : {
                     "localId" : "310",
                     "locator" : "61:3-66:7",
                     "type" : "Union",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "288",
                        "locator" : "61:5-61:72",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "283",
                           "locator" : "61:5-61:72",
                           "alias" : "RightMastectomyProcedure",
                           "expression" : {
                              "localId" : "286",
                              "locator" : "61:5-61:47",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "285",
                                 "locator" : "61:17-61:46",
                                 "name" : "Status Post Right Mastectomy",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }
                        } ],
                        "let" : [ ],
                        "relationship" : [ ]
                     }, {
                        "localId" : "309",
                        "locator" : "62:11-66:5",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "289",
                           "locator" : "62:13-62:102",
                           "alias" : "UnilateralMastectomyDiagnosis",
                           "expression" : {
                              "localId" : "292",
                              "locator" : "62:13-62:72",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "291",
                                 "locator" : "62:25-62:71",
                                 "name" : "Unilateral Mastectomy, Unspecified Laterality",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }
                        } ],
                        "let" : [ ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "294",
                           "locator" : "63:9-65:9",
                           "type" : "Exists",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "308",
                              "locator" : "63:22-65:9",
                              "type" : "Query",
                              "source" : [ {
                                 "localId" : "295",
                                 "locator" : "63:24-63:63",
                                 "alias" : "S",
                                 "expression" : {
                                    "localId" : "298",
                                    "locator" : "63:24-63:61",
                                    "type" : "Query",
                                    "source" : [ {
                                       "localId" : "299",
                                       "alias" : "$this",
                                       "expression" : {
                                          "localId" : "297",
                                          "path" : "bodySite",
                                          "scope" : "UnilateralMastectomyDiagnosis",
                                          "type" : "Property"
                                       }
                                    } ],
                                    "let" : [ ],
                                    "relationship" : [ ],
                                    "return" : {
                                       "localId" : "302",
                                       "distinct" : false,
                                       "expression" : {
                                          "localId" : "300",
                                          "name" : "ToConcept",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "301",
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          } ]
                                       }
                                    }
                                 }
                              } ],
                              "let" : [ ],
                              "relationship" : [ ],
                              "where" : {
                                 "localId" : "303",
                                 "locator" : "64:13-64:47",
                                 "type" : "Equivalent",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "304",
                                    "locator" : "64:19",
                                    "name" : "S",
                                    "type" : "AliasRef"
                                 }, {
                                    "localId" : "307",
                                    "type" : "ToConcept",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "305",
                                       "locator" : "64:23-64:47",
                                       "name" : "Right (qualifier value)",
                                       "type" : "CodeRef"
                                    }
                                 } ]
                              }
                           }
                        }
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "316",
                  "locator" : "67:5-67:96",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "315",
                     "locator" : "67:50-67:55",
                     "type" : "Start",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "312",
                        "locator" : "67:11-67:48",
                        "name" : "prevalenceInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "311",
                           "locator" : "67:11-67:25",
                           "name" : "RightMastectomy",
                           "type" : "AliasRef"
                        } ]
                     }
                  }, {
                     "localId" : "313",
                     "locator" : "67:70-67:96",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "314",
                        "locator" : "67:77-67:96",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "321",
            "locator" : "69:1-71:115",
            "name" : "Right Mastectomy Procedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "321",
                  "s" : [ {
                     "value" : [ "","define ","\"Right Mastectomy Procedure\"",":\n  " ]
                  }, {
                     "r" : "336",
                     "s" : [ {
                        "s" : [ {
                           "r" : "322",
                           "s" : [ {
                              "r" : "327",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "327",
                                 "s" : [ {
                                    "r" : "325",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "325",
                                       "s" : [ {
                                          "value" : [ "[","Procedure",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Unilateral Mastectomy Right\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "327",
                                    "s" : [ {
                                       "value" : [ "isProcedurePerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","UnilateralMastectomyRightPerformed" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "335",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "335",
                           "s" : [ {
                              "r" : "331",
                              "s" : [ {
                                 "r" : "330",
                                 "s" : [ {
                                    "r" : "328",
                                    "s" : [ {
                                       "value" : [ "UnilateralMastectomyRightPerformed" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "330",
                                    "s" : [ {
                                       "value" : [ "performed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "331",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "335",
                              "value" : [ " ","ends on or before"," " ]
                           }, {
                              "r" : "332",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "333",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "336",
               "locator" : "70:3-71:115",
               "type" : "Query",
               "source" : [ {
                  "localId" : "322",
                  "locator" : "70:3-70:112",
                  "alias" : "UnilateralMastectomyRightPerformed",
                  "expression" : {
                     "localId" : "327",
                     "locator" : "70:3-70:77",
                     "name" : "isProcedurePerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "325",
                        "locator" : "70:5-70:50",
                        "dataType" : "{http://hl7.org/fhir}Procedure",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "324",
                           "locator" : "70:19-70:47",
                           "name" : "Unilateral Mastectomy Right",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "335",
                  "locator" : "71:5-71:115",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "334",
                     "locator" : "71:71-71:74",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "331",
                        "locator" : "71:11-71:69",
                        "name" : "toInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "330",
                           "locator" : "71:11-71:54",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "329",
                              "path" : "performed",
                              "scope" : "UnilateralMastectomyRightPerformed",
                              "type" : "Property"
                           } ]
                        } ]
                     }
                  }, {
                     "localId" : "332",
                     "locator" : "71:89-71:115",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "333",
                        "locator" : "71:96-71:115",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "341",
            "locator" : "73:1-80:95",
            "name" : "Left Mastectomy Diagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "341",
                  "s" : [ {
                     "value" : [ "","define ","\"Left Mastectomy Diagnosis\"",":\n  " ]
                  }, {
                     "r" : "375",
                     "s" : [ {
                        "s" : [ {
                           "r" : "342",
                           "s" : [ {
                              "r" : "368",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "368",
                                 "s" : [ {
                                    "r" : "345",
                                    "s" : [ {
                                       "value" : [ "[","Condition",": " ]
                                    }, {
                                       "s" : [ {
                                          "value" : [ "\"Status Post Left Mastectomy\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    union " ]
                                 }, {
                                    "r" : "367",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "367",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "347",
                                             "s" : [ {
                                                "r" : "350",
                                                "s" : [ {
                                                   "r" : "350",
                                                   "s" : [ {
                                                      "value" : [ "[","Condition",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Unilateral Mastectomy, Unspecified Laterality\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","UnilateralMastectomyDiagnosis" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "r" : "352",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "352",
                                             "s" : [ {
                                                "value" : [ "exists " ]
                                             }, {
                                                "r" : "366",
                                                "s" : [ {
                                                   "value" : [ "( " ]
                                                }, {
                                                   "r" : "366",
                                                   "s" : [ {
                                                      "s" : [ {
                                                         "r" : "353",
                                                         "s" : [ {
                                                            "r" : "356",
                                                            "s" : [ {
                                                               "s" : [ {
                                                                  "value" : [ "UnilateralMastectomyDiagnosis",".","bodySite" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","S" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n            " ]
                                                   }, {
                                                      "r" : "361",
                                                      "s" : [ {
                                                         "value" : [ "where " ]
                                                      }, {
                                                         "r" : "361",
                                                         "s" : [ {
                                                            "r" : "362",
                                                            "s" : [ {
                                                               "value" : [ "S" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " ","~"," " ]
                                                         }, {
                                                            "r" : "363",
                                                            "s" : [ {
                                                               "value" : [ "\"Left (qualifier value)\"" ]
                                                            } ]
                                                         } ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n        )" ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","LeftMastectomy" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "374",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "374",
                           "s" : [ {
                              "r" : "370",
                              "s" : [ {
                                 "r" : "369",
                                 "s" : [ {
                                    "value" : [ "LeftMastectomy" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "370",
                                 "s" : [ {
                                    "value" : [ "prevalenceInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "374",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "371",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "372",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "375",
               "locator" : "74:3-80:95",
               "type" : "Query",
               "source" : [ {
                  "localId" : "342",
                  "locator" : "74:3-79:22",
                  "alias" : "LeftMastectomy",
                  "expression" : {
                     "localId" : "368",
                     "locator" : "74:3-79:7",
                     "type" : "Union",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "345",
                        "locator" : "74:5-74:46",
                        "dataType" : "{http://hl7.org/fhir}Condition",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "344",
                           "locator" : "74:17-74:45",
                           "name" : "Status Post Left Mastectomy",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     }, {
                        "localId" : "367",
                        "locator" : "75:11-79:5",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "347",
                           "locator" : "75:13-75:102",
                           "alias" : "UnilateralMastectomyDiagnosis",
                           "expression" : {
                              "localId" : "350",
                              "locator" : "75:13-75:72",
                              "dataType" : "{http://hl7.org/fhir}Condition",
                              "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                              "codeProperty" : "code",
                              "codeComparator" : "in",
                              "type" : "Retrieve",
                              "codes" : {
                                 "localId" : "349",
                                 "locator" : "75:25-75:71",
                                 "name" : "Unilateral Mastectomy, Unspecified Laterality",
                                 "preserve" : true,
                                 "type" : "ValueSetRef"
                              },
                              "include" : [ ],
                              "codeFilter" : [ ],
                              "dateFilter" : [ ],
                              "otherFilter" : [ ]
                           }
                        } ],
                        "let" : [ ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "352",
                           "locator" : "76:9-78:9",
                           "type" : "Exists",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "366",
                              "locator" : "76:22-78:9",
                              "type" : "Query",
                              "source" : [ {
                                 "localId" : "353",
                                 "locator" : "76:24-76:63",
                                 "alias" : "S",
                                 "expression" : {
                                    "localId" : "356",
                                    "locator" : "76:24-76:61",
                                    "type" : "Query",
                                    "source" : [ {
                                       "localId" : "357",
                                       "alias" : "$this",
                                       "expression" : {
                                          "localId" : "355",
                                          "path" : "bodySite",
                                          "scope" : "UnilateralMastectomyDiagnosis",
                                          "type" : "Property"
                                       }
                                    } ],
                                    "let" : [ ],
                                    "relationship" : [ ],
                                    "return" : {
                                       "localId" : "360",
                                       "distinct" : false,
                                       "expression" : {
                                          "localId" : "358",
                                          "name" : "ToConcept",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "signature" : [ ],
                                          "operand" : [ {
                                             "localId" : "359",
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          } ]
                                       }
                                    }
                                 }
                              } ],
                              "let" : [ ],
                              "relationship" : [ ],
                              "where" : {
                                 "localId" : "361",
                                 "locator" : "77:13-77:46",
                                 "type" : "Equivalent",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "362",
                                    "locator" : "77:19",
                                    "name" : "S",
                                    "type" : "AliasRef"
                                 }, {
                                    "localId" : "365",
                                    "type" : "ToConcept",
                                    "signature" : [ ],
                                    "operand" : {
                                       "localId" : "363",
                                       "locator" : "77:23-77:46",
                                       "name" : "Left (qualifier value)",
                                       "type" : "CodeRef"
                                    }
                                 } ]
                              }
                           }
                        }
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "374",
                  "locator" : "80:5-80:95",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "373",
                     "locator" : "80:49-80:54",
                     "type" : "Start",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "370",
                        "locator" : "80:11-80:47",
                        "name" : "prevalenceInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "369",
                           "locator" : "80:11-80:24",
                           "name" : "LeftMastectomy",
                           "type" : "AliasRef"
                        } ]
                     }
                  }, {
                     "localId" : "371",
                     "locator" : "80:69-80:95",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "372",
                        "locator" : "80:76-80:95",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "379",
            "locator" : "82:1-84:114",
            "name" : "Left Mastectomy Procedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "379",
                  "s" : [ {
                     "value" : [ "","define ","\"Left Mastectomy Procedure\"",":\n  " ]
                  }, {
                     "r" : "394",
                     "s" : [ {
                        "s" : [ {
                           "r" : "380",
                           "s" : [ {
                              "r" : "385",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "385",
                                 "s" : [ {
                                    "r" : "383",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "383",
                                       "s" : [ {
                                          "value" : [ "[","Procedure",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Unilateral Mastectomy Left\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "385",
                                    "s" : [ {
                                       "value" : [ "isProcedurePerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","UnilateralMastectomyLeftPerformed" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "393",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "393",
                           "s" : [ {
                              "r" : "389",
                              "s" : [ {
                                 "r" : "388",
                                 "s" : [ {
                                    "r" : "386",
                                    "s" : [ {
                                       "value" : [ "UnilateralMastectomyLeftPerformed" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "388",
                                    "s" : [ {
                                       "value" : [ "performed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "389",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "393",
                              "value" : [ " ","ends on or before"," " ]
                           }, {
                              "r" : "390",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "391",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "394",
               "locator" : "83:3-84:114",
               "type" : "Query",
               "source" : [ {
                  "localId" : "380",
                  "locator" : "83:3-83:110",
                  "alias" : "UnilateralMastectomyLeftPerformed",
                  "expression" : {
                     "localId" : "385",
                     "locator" : "83:3-83:76",
                     "name" : "isProcedurePerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "383",
                        "locator" : "83:5-83:49",
                        "dataType" : "{http://hl7.org/fhir}Procedure",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "382",
                           "locator" : "83:19-83:46",
                           "name" : "Unilateral Mastectomy Left",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "393",
                  "locator" : "84:5-84:114",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "392",
                     "locator" : "84:70-84:73",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "389",
                        "locator" : "84:11-84:68",
                        "name" : "toInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "388",
                           "locator" : "84:11-84:53",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "387",
                              "path" : "performed",
                              "scope" : "UnilateralMastectomyLeftPerformed",
                              "type" : "Property"
                           } ]
                        } ]
                     }
                  }, {
                     "localId" : "390",
                     "locator" : "84:88-84:114",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "391",
                        "locator" : "84:95-84:114",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "398",
            "locator" : "86:1-88:107",
            "name" : "Bilateral Mastectomy Diagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "398",
                  "s" : [ {
                     "value" : [ "","define ","\"Bilateral Mastectomy Diagnosis\"",":\n  " ]
                  }, {
                     "r" : "410",
                     "s" : [ {
                        "s" : [ {
                           "r" : "399",
                           "s" : [ {
                              "r" : "402",
                              "s" : [ {
                                 "r" : "402",
                                 "s" : [ {
                                    "value" : [ "[","Condition",": " ]
                                 }, {
                                    "s" : [ {
                                       "value" : [ "\"History of bilateral mastectomy\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","BilateralMastectomyHistory" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "409",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "409",
                           "s" : [ {
                              "r" : "405",
                              "s" : [ {
                                 "r" : "404",
                                 "s" : [ {
                                    "value" : [ "BilateralMastectomyHistory" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "405",
                                 "s" : [ {
                                    "value" : [ "prevalenceInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "409",
                              "value" : [ " ","starts on or before"," " ]
                           }, {
                              "r" : "406",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "407",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "410",
               "locator" : "87:3-88:107",
               "type" : "Query",
               "source" : [ {
                  "localId" : "399",
                  "locator" : "87:3-87:75",
                  "alias" : "BilateralMastectomyHistory",
                  "expression" : {
                     "localId" : "402",
                     "locator" : "87:3-87:48",
                     "dataType" : "{http://hl7.org/fhir}Condition",
                     "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-condition",
                     "codeProperty" : "code",
                     "codeComparator" : "in",
                     "type" : "Retrieve",
                     "codes" : {
                        "localId" : "401",
                        "locator" : "87:15-87:47",
                        "name" : "History of bilateral mastectomy",
                        "preserve" : true,
                        "type" : "ValueSetRef"
                     },
                     "include" : [ ],
                     "codeFilter" : [ ],
                     "dateFilter" : [ ],
                     "otherFilter" : [ ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "409",
                  "locator" : "88:5-88:107",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "408",
                     "locator" : "88:61-88:66",
                     "type" : "Start",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "405",
                        "locator" : "88:11-88:59",
                        "name" : "prevalenceInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "404",
                           "locator" : "88:11-88:36",
                           "name" : "BilateralMastectomyHistory",
                           "type" : "AliasRef"
                        } ]
                     }
                  }, {
                     "localId" : "406",
                     "locator" : "88:81-88:107",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "407",
                        "locator" : "88:88-88:107",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "414",
            "locator" : "90:1-92:109",
            "name" : "Bilateral Mastectomy Procedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "414",
                  "s" : [ {
                     "value" : [ "","define ","\"Bilateral Mastectomy Procedure\"",":\n  " ]
                  }, {
                     "r" : "429",
                     "s" : [ {
                        "s" : [ {
                           "r" : "415",
                           "s" : [ {
                              "r" : "420",
                              "s" : [ {
                                 "value" : [ "( " ]
                              }, {
                                 "r" : "420",
                                 "s" : [ {
                                    "r" : "418",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "418",
                                       "s" : [ {
                                          "value" : [ "[","Procedure",": " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "\"Bilateral Mastectomy\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "]" ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "420",
                                    "s" : [ {
                                       "value" : [ "isProcedurePerformed"," ( )" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " )" ]
                              } ]
                           }, {
                              "value" : [ " ","BilateralMastectomyPerformed" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "428",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "428",
                           "s" : [ {
                              "r" : "424",
                              "s" : [ {
                                 "r" : "423",
                                 "s" : [ {
                                    "r" : "421",
                                    "s" : [ {
                                       "value" : [ "BilateralMastectomyPerformed" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "423",
                                    "s" : [ {
                                       "value" : [ "performed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "424",
                                 "s" : [ {
                                    "value" : [ "toInterval"," ( )" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "428",
                              "value" : [ " ","ends on or before"," " ]
                           }, {
                              "r" : "425",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "426",
                                 "s" : [ {
                                    "value" : [ "\"Measurement Period\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "429",
               "locator" : "91:3-92:109",
               "type" : "Query",
               "source" : [ {
                  "localId" : "415",
                  "locator" : "91:3-91:99",
                  "alias" : "BilateralMastectomyPerformed",
                  "expression" : {
                     "localId" : "420",
                     "locator" : "91:3-91:70",
                     "name" : "isProcedurePerformed",
                     "libraryName" : "Status",
                     "type" : "FunctionRef",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "418",
                        "locator" : "91:5-91:43",
                        "dataType" : "{http://hl7.org/fhir}Procedure",
                        "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-procedure",
                        "codeProperty" : "code",
                        "codeComparator" : "in",
                        "type" : "Retrieve",
                        "codes" : {
                           "localId" : "417",
                           "locator" : "91:19-91:40",
                           "name" : "Bilateral Mastectomy",
                           "preserve" : true,
                           "type" : "ValueSetRef"
                        },
                        "include" : [ ],
                        "codeFilter" : [ ],
                        "dateFilter" : [ ],
                        "otherFilter" : [ ]
                     } ]
                  }
               } ],
               "let" : [ ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "428",
                  "locator" : "92:5-92:109",
                  "type" : "SameOrBefore",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "427",
                     "locator" : "92:65-92:68",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "424",
                        "locator" : "92:11-92:63",
                        "name" : "toInterval",
                        "libraryName" : "QICoreCommon",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "423",
                           "locator" : "92:11-92:48",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "422",
                              "path" : "performed",
                              "scope" : "BilateralMastectomyPerformed",
                              "type" : "Property"
                           } ]
                        } ]
                     }
                  }, {
                     "localId" : "425",
                     "locator" : "92:83-92:109",
                     "type" : "End",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "426",
                        "locator" : "92:90-92:109",
                        "name" : "Measurement Period",
                        "type" : "ParameterRef"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "268",
            "locator" : "45:1-58:69",
            "name" : "Denominator Exclusions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "268",
                  "s" : [ {
                     "value" : [ "","define ","\"Denominator Exclusions\"",":\n  " ]
                  }, {
                     "r" : "269",
                     "s" : [ {
                        "r" : "270",
                        "s" : [ {
                           "r" : "271",
                           "s" : [ {
                              "r" : "272",
                              "s" : [ {
                                 "r" : "273",
                                 "s" : [ {
                                    "r" : "274",
                                    "s" : [ {
                                       "r" : "276",
                                       "s" : [ {
                                          "r" : "275",
                                          "s" : [ {
                                             "value" : [ "Hospice" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "276",
                                          "s" : [ {
                                             "value" : [ "\"Has Hospice Services\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    or " ]
                                    }, {
                                       "r" : "277",
                                       "s" : [ {
                                          "value" : [ "( " ]
                                       }, {
                                          "r" : "277",
                                          "s" : [ {
                                             "r" : "278",
                                             "s" : [ {
                                                "value" : [ "( " ]
                                             }, {
                                                "r" : "278",
                                                "s" : [ {
                                                   "r" : "279",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "318",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "318",
                                                         "s" : [ {
                                                            "value" : [ "\"Right Mastectomy Diagnosis\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n          or " ]
                                                }, {
                                                   "r" : "319",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "337",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "337",
                                                         "s" : [ {
                                                            "value" : [ "\"Right Mastectomy Procedure\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n      )" ]
                                             } ]
                                          }, {
                                             "value" : [ "\n        and " ]
                                          }, {
                                             "r" : "338",
                                             "s" : [ {
                                                "value" : [ "( " ]
                                             }, {
                                                "r" : "338",
                                                "s" : [ {
                                                   "r" : "339",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "376",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "376",
                                                         "s" : [ {
                                                            "value" : [ "\"Left Mastectomy Diagnosis\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n            or " ]
                                                }, {
                                                   "r" : "377",
                                                   "s" : [ {
                                                      "value" : [ "exists " ]
                                                   }, {
                                                      "r" : "395",
                                                      "s" : [ {
                                                         "value" : [ "( " ]
                                                      }, {
                                                         "r" : "395",
                                                         "s" : [ {
                                                            "value" : [ "\"Left Mastectomy Procedure\"" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " )" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n        )" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n    )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    or " ]
                                 }, {
                                    "r" : "396",
                                    "s" : [ {
                                       "value" : [ "exists " ]
                                    }, {
                                       "r" : "411",
                                       "s" : [ {
                                          "value" : [ "\"Bilateral Mastectomy Diagnosis\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    or " ]
                              }, {
                                 "r" : "412",
                                 "s" : [ {
                                    "value" : [ "exists " ]
                                 }, {
                                    "r" : "430",
                                    "s" : [ {
                                       "value" : [ "\"Bilateral Mastectomy Procedure\"" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    or " ]
                           }, {
                              "r" : "432",
                              "s" : [ {
                                 "r" : "431",
                                 "s" : [ {
                                    "value" : [ "AIFrailLTCF" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "432",
                                 "s" : [ {
                                    "value" : [ "\"Is Age 66 or Older with Advanced Illness and Frailty\"" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "434",
                           "s" : [ {
                              "r" : "433",
                              "s" : [ {
                                 "value" : [ "AIFrailLTCF" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "434",
                              "s" : [ {
                                 "value" : [ "\"Is Age 66 or Older Living Long Term in a Nursing Home\"" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    or " ]
                     }, {
                        "r" : "436",
                        "s" : [ {
                           "r" : "435",
                           "s" : [ {
                              "value" : [ "PalliativeCare" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "436",
                           "s" : [ {
                              "value" : [ "\"Has Palliative Care in the Measurement Period\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "269",
               "locator" : "46:3-58:69",
               "type" : "Or",
               "signature" : [ ],
               "operand" : [ {
                  "localId" : "270",
                  "locator" : "46:3-57:74",
                  "type" : "Or",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "271",
                     "locator" : "46:3-56:73",
                     "type" : "Or",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "272",
                        "locator" : "46:3-55:46",
                        "type" : "Or",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "273",
                           "locator" : "46:3-54:46",
                           "type" : "Or",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "274",
                              "locator" : "46:3-53:5",
                              "type" : "Or",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "276",
                                 "locator" : "46:3-46:32",
                                 "name" : "Has Hospice Services",
                                 "libraryName" : "Hospice",
                                 "type" : "ExpressionRef"
                              }, {
                                 "localId" : "277",
                                 "locator" : "47:8-53:5",
                                 "type" : "And",
                                 "signature" : [ ],
                                 "operand" : [ {
                                    "localId" : "278",
                                    "locator" : "47:10-49:7",
                                    "type" : "Or",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "279",
                                       "locator" : "47:12-47:50",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "318",
                                          "locator" : "47:19-47:50",
                                          "name" : "Right Mastectomy Diagnosis",
                                          "type" : "ExpressionRef"
                                       }
                                    }, {
                                       "localId" : "319",
                                       "locator" : "48:14-48:52",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "337",
                                          "locator" : "48:21-48:52",
                                          "name" : "Right Mastectomy Procedure",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 }, {
                                    "localId" : "338",
                                    "locator" : "50:13-52:9",
                                    "type" : "Or",
                                    "signature" : [ ],
                                    "operand" : [ {
                                       "localId" : "339",
                                       "locator" : "50:15-50:52",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "376",
                                          "locator" : "50:22-50:52",
                                          "name" : "Left Mastectomy Diagnosis",
                                          "type" : "ExpressionRef"
                                       }
                                    }, {
                                       "localId" : "377",
                                       "locator" : "51:16-51:53",
                                       "type" : "Exists",
                                       "signature" : [ ],
                                       "operand" : {
                                          "localId" : "395",
                                          "locator" : "51:23-51:53",
                                          "name" : "Left Mastectomy Procedure",
                                          "type" : "ExpressionRef"
                                       }
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "localId" : "396",
                              "locator" : "54:8-54:46",
                              "type" : "Exists",
                              "signature" : [ ],
                              "operand" : {
                                 "localId" : "411",
                                 "locator" : "54:15-54:46",
                                 "name" : "Bilateral Mastectomy Diagnosis",
                                 "type" : "ExpressionRef"
                              }
                           } ]
                        }, {
                           "localId" : "412",
                           "locator" : "55:8-55:46",
                           "type" : "Exists",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "430",
                              "locator" : "55:15-55:46",
                              "name" : "Bilateral Mastectomy Procedure",
                              "type" : "ExpressionRef"
                           }
                        } ]
                     }, {
                        "localId" : "432",
                        "locator" : "56:8-56:73",
                        "name" : "Is Age 66 or Older with Advanced Illness and Frailty",
                        "libraryName" : "AIFrailLTCF",
                        "type" : "ExpressionRef"
                     } ]
                  }, {
                     "localId" : "434",
                     "locator" : "57:8-57:74",
                     "name" : "Is Age 66 or Older Living Long Term in a Nursing Home",
                     "libraryName" : "AIFrailLTCF",
                     "type" : "ExpressionRef"
                  } ]
               }, {
                  "localId" : "436",
                  "locator" : "58:8-58:69",
                  "name" : "Has Palliative Care in the Measurement Period",
                  "libraryName" : "PalliativeCare",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "451",
            "locator" : "99:1-100:79",
            "name" : "October 1 Two Years Prior to the Measurement Period",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "451",
                  "s" : [ {
                     "value" : [ "","define ","\"October 1 Two Years Prior to the Measurement Period\"",":\n  " ]
                  }, {
                     "r" : "468",
                     "s" : [ {
                        "value" : [ "DateTime","(" ]
                     }, {
                        "r" : "452",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "452",
                           "s" : [ {
                              "r" : "453",
                              "s" : [ {
                                 "value" : [ "year from " ]
                              }, {
                                 "r" : "454",
                                 "s" : [ {
                                    "value" : [ "start of " ]
                                 }, {
                                    "r" : "455",
                                    "s" : [ {
                                       "value" : [ "\"Measurement Period\"" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "r" : "456",
                              "value" : [ " - ","2" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     }, {
                        "r" : "457",
                        "value" : [ ", ","10",", ","1",", ","0",", ","0",", ","0",", ","0",", ","0",")" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "468",
               "locator" : "100:3-100:79",
               "type" : "DateTime",
               "signature" : [ ],
               "year" : {
                  "localId" : "452",
                  "locator" : "100:12-100:56",
                  "type" : "Subtract",
                  "signature" : [ ],
                  "operand" : [ {
                     "localId" : "453",
                     "locator" : "100:13-100:51",
                     "precision" : "Year",
                     "type" : "DateTimeComponentFrom",
                     "signature" : [ ],
                     "operand" : {
                        "localId" : "454",
                        "locator" : "100:23-100:51",
                        "type" : "Start",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "455",
                           "locator" : "100:32-100:51",
                           "name" : "Measurement Period",
                           "type" : "ParameterRef"
                        }
                     }
                  }, {
                     "localId" : "456",
                     "locator" : "100:55",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "2",
                     "type" : "Literal"
                  } ]
               },
               "month" : {
                  "localId" : "457",
                  "locator" : "100:59-100:60",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "10",
                  "type" : "Literal"
               },
               "day" : {
                  "localId" : "458",
                  "locator" : "100:63",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "1",
                  "type" : "Literal"
               },
               "hour" : {
                  "localId" : "459",
                  "locator" : "100:66",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "minute" : {
                  "localId" : "460",
                  "locator" : "100:69",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "second" : {
                  "localId" : "461",
                  "locator" : "100:72",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "millisecond" : {
                  "localId" : "462",
                  "locator" : "100:75",
                  "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "value" : "0",
                  "type" : "Literal"
               },
               "timezoneOffset" : {
                  "localId" : "470",
                  "type" : "ToDecimal",
                  "signature" : [ ],
                  "operand" : {
                     "localId" : "463",
                     "locator" : "100:78",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                     "value" : "0",
                     "type" : "Literal"
                  }
               }
            }
         }, {
            "localId" : "438",
            "locator" : "94:1-97:3",
            "name" : "Numerator",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "438",
                  "s" : [ {
                     "value" : [ "","define ","\"Numerator\"",":\n  " ]
                  }, {
                     "r" : "439",
                     "s" : [ {
                        "value" : [ "exists " ]
                     }, {
                        "r" : "477",
                        "s" : [ {
                           "value" : [ "( " ]
                        }, {
                           "r" : "477",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "440",
                                 "s" : [ {
                                    "r" : "445",
                                    "s" : [ {
                                       "value" : [ "( " ]
                                    }, {
                                       "r" : "445",
                                       "s" : [ {
                                          "r" : "443",
                                          "s" : [ {
                                             "value" : [ "( " ]
                                          }, {
                                             "r" : "443",
                                             "s" : [ {
                                                "value" : [ "[","Observation",": " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "\"Mammography\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          }, {
                                             "value" : [ " )" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "445",
                                          "s" : [ {
                                             "value" : [ "isDiagnosticStudyPerformed"," ( )" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " )" ]
                                    } ]
                                 }, {
                                    "value" : [ " ","Mammogram" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "476",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "476",
                                 "s" : [ {
                                    "r" : "449",
                                    "s" : [ {
                                       "r" : "448",
                                       "s" : [ {
                                          "r" : "446",
                                          "s" : [ {
                                             "value" : [ "Mammogram" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "448",
                                          "s" : [ {
                                             "value" : [ "effective" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "449",
                                       "s" : [ {
                                          "value" : [ "toInterval"," ( )" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "476",
                                    "value" : [ " ","ends during day of"," " ]
                                 }, {
                                    "r" : "474",
                                    "s" : [ {
                                       "value" : [ "Interval[" ]
                                    }, {
                                       "r" : "471",
                                       "s" : [ {
                                          "value" : [ "\"October 1 Two Years Prior to the Measurement Period\"" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "472",
                                       "s" : [ {
                                          "value" : [ "end of " ]
                                       }, {
                                          "r" : "473",
                                          "s" : [ {
                                             "value" : [ "\"Measurement Period\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "439",
               "locator" : "95:3-97:3",
               "type" : "Exists",
               "signature" : [ ],
               "operand" : {
                  "localId" : "477",
                  "locator" : "95:10-97:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "440",
                     "locator" : "95:12-95:88",
                     "alias" : "Mammogram",
                     "expression" : {
                        "localId" : "445",
                        "locator" : "95:12-95:78",
                        "name" : "isDiagnosticStudyPerformed",
                        "libraryName" : "Status",
                        "type" : "FunctionRef",
                        "signature" : [ ],
                        "operand" : [ {
                           "localId" : "443",
                           "locator" : "95:14-95:45",
                           "dataType" : "{http://hl7.org/fhir}Observation",
                           "templateId" : "http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-observation",
                           "codeProperty" : "code",
                           "codeComparator" : "in",
                           "type" : "Retrieve",
                           "codes" : {
                              "localId" : "442",
                              "locator" : "95:30-95:42",
                              "name" : "Mammography",
                              "preserve" : true,
                              "type" : "ValueSetRef"
                           },
                           "include" : [ ],
                           "codeFilter" : [ ],
                           "dateFilter" : [ ],
                           "otherFilter" : [ ]
                        } ]
                     }
                  } ],
                  "let" : [ ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "476",
                     "locator" : "96:7-96:158",
                     "precision" : "Day",
                     "type" : "In",
                     "signature" : [ ],
                     "operand" : [ {
                        "localId" : "475",
                        "locator" : "96:48-96:51",
                        "type" : "End",
                        "signature" : [ ],
                        "operand" : {
                           "localId" : "449",
                           "locator" : "96:13-96:46",
                           "name" : "toInterval",
                           "libraryName" : "QICoreCommon",
                           "type" : "FunctionRef",
                           "signature" : [ ],
                           "operand" : [ {
                              "localId" : "448",
                              "locator" : "96:13-96:31",
                              "name" : "ToValue",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "signature" : [ ],
                              "operand" : [ {
                                 "localId" : "447",
                                 "path" : "effective",
                                 "scope" : "Mammogram",
                                 "type" : "Property"
                              } ]
                           } ]
                        }
                     }, {
                        "localId" : "474",
                        "locator" : "96:67-96:158",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "471",
                           "locator" : "96:76-96:128",
                           "name" : "October 1 Two Years Prior to the Measurement Period",
                           "type" : "ExpressionRef"
                        },
                        "high" : {
                           "localId" : "472",
                           "locator" : "96:131-96:157",
                           "type" : "End",
                           "signature" : [ ],
                           "operand" : {
                              "localId" : "473",
                              "locator" : "96:138-96:157",
                              "name" : "Measurement Period",
                              "type" : "ParameterRef"
                           }
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "479",
            "locator" : "102:1-103:21",
            "name" : "SDE Ethnicity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "479",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Ethnicity\"",":\n  " ]
                  }, {
                     "r" : "481",
                     "s" : [ {
                        "r" : "480",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "481",
                        "s" : [ {
                           "value" : [ "\"SDE Ethnicity\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "481",
               "locator" : "103:3-103:21",
               "name" : "SDE Ethnicity",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "483",
            "locator" : "105:1-106:17",
            "name" : "SDE Payer",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "483",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Payer\"",":\n  " ]
                  }, {
                     "r" : "485",
                     "s" : [ {
                        "r" : "484",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "485",
                        "s" : [ {
                           "value" : [ "\"SDE Payer\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "485",
               "locator" : "106:3-106:17",
               "name" : "SDE Payer",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "487",
            "locator" : "108:1-109:16",
            "name" : "SDE Race",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "487",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Race\"",":\n  " ]
                  }, {
                     "r" : "489",
                     "s" : [ {
                        "r" : "488",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "489",
                        "s" : [ {
                           "value" : [ "\"SDE Race\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "489",
               "locator" : "109:3-109:16",
               "name" : "SDE Race",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "491",
            "locator" : "111:1-112:15",
            "name" : "SDE Sex",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "491",
                  "s" : [ {
                     "value" : [ "","define ","\"SDE Sex\"",":\n  " ]
                  }, {
                     "r" : "493",
                     "s" : [ {
                        "r" : "492",
                        "s" : [ {
                           "value" : [ "SDE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "493",
                        "s" : [ {
                           "value" : [ "\"SDE Sex\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "493",
               "locator" : "112:3-112:15",
               "name" : "SDE Sex",
               "libraryName" : "SDE",
               "type" : "ExpressionRef"
            }
         } ]
      }
   }
}" + } + ] + }, + "request": { + "method": "PUT", + "url": "Measure/BreastCancerScreeningFHIR" + } + } + ] +}