diff --git a/form-api/src/main/java/ai/stapi/formapi/FormEndpoint.java b/form-api/src/main/java/ai/stapi/formapi/FormEndpoint.java
index cefcb00c..d3a86eb9 100644
--- a/form-api/src/main/java/ai/stapi/formapi/FormEndpoint.java
+++ b/form-api/src/main/java/ai/stapi/formapi/FormEndpoint.java
@@ -7,6 +7,7 @@
 import java.util.Map;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -30,17 +31,21 @@ public FormEndpoint(
     this.operationDefinitionProvider = operationDefinitionProvider;
   }
 
-  @GetMapping("/form/{operationId}/")
+  @GetMapping({
+      "/form/{operationId}",
+      "/form/{operationId}/{resourceId}",
+  })
   @ResponseBody
   public Map<String, Object> form(
       @PathVariable String operationId,
-      @PathVariable String resourceId,
-      @PathVariable String startModificationNodeIdAndType
+      @PathVariable(required = false) String resourceId,
+      @RequestParam(required = false) String startModificationNodeIdAndType,
+      @RequestParam(required = false, defaultValue = "true") Boolean omitExtension
   ) {
     var operation = this.operationDefinitionProvider.provide(operationId);
 
     return Map.of(
-        "formSchema", this.jsonSchemaMapper.map(operation),
+        "formSchema", this.jsonSchemaMapper.map(operation, omitExtension),
         "uiSchema", this.uiSchemaLoader.load(operation),
         "formData", this.formDataLoader.load(operation, resourceId, startModificationNodeIdAndType)
     );
diff --git a/form-api/src/main/java/ai/stapi/formapi/formmapper/JsonSchemaMapper.java b/form-api/src/main/java/ai/stapi/formapi/formmapper/JsonSchemaMapper.java
index 9e1f0809..0bceaee9 100644
--- a/form-api/src/main/java/ai/stapi/formapi/formmapper/JsonSchemaMapper.java
+++ b/form-api/src/main/java/ai/stapi/formapi/formmapper/JsonSchemaMapper.java
@@ -84,15 +84,22 @@ public JsonSchemaMapper(
   }
 
   public Map<String, Object> map(OperationDefinitionDTO operationDefinitionDTO) {
-    var fakedStructureType = this.operationDefinitionStructureTypeMapper.map(operationDefinitionDTO);
+    return this.map(operationDefinitionDTO, true);
+  }
+
+  public Map<String, Object> map(OperationDefinitionDTO operationDefinitionDTO,
+                                 Boolean omitExtension) {
+    var fakedStructureType = this.operationDefinitionStructureTypeMapper.map(
+        operationDefinitionDTO);
     var formMapperContext = new FormMapperContext();
-    var schema = this.getObjectSchema(fakedStructureType, formMapperContext);
+    var schema = this.getObjectSchema(fakedStructureType, formMapperContext, omitExtension);
     return this.printSchema(schema, formMapperContext);
   }
 
   private ObjectSchema getObjectSchema(
       ComplexStructureType complexStructureType,
-      FormMapperContext formMapperContext
+      FormMapperContext formMapperContext,
+      Boolean omitExtension
   ) {
     var builder = new ObjectSchema.Builder();
     builder.title(complexStructureType.getDefinitionType());
@@ -102,8 +109,10 @@ private ObjectSchema getObjectSchema(
     complexStructureType.getAllFields()
         .values()
         .stream()
+        .filter(field -> !omitExtension || (!field.getName().equals("extension") &&
+            !field.getName().equals("modifierExtension")))
         .sorted(Comparator.comparing(FieldDefinition::getName))
-        .forEach(field -> this.mapField(field, builder, formMapperContext));
+        .forEach(field -> this.mapField(field, builder, formMapperContext, omitExtension));
 
     return builder.build();
   }
@@ -111,7 +120,8 @@ private ObjectSchema getObjectSchema(
   private void mapField(
       FieldDefinition field,
       ObjectSchema.Builder builder,
-      FormMapperContext formMapperContext
+      FormMapperContext formMapperContext,
+      Boolean omitExtension
   ) {
     var parameterName = field.getName();
     if (field.getMin() > 0) {
@@ -121,30 +131,35 @@ private void mapField(
       return;
     }
     if (field.getFloatMax() > 1) {
-      this.mapArrayField(field, builder, formMapperContext);
+      this.mapArrayField(field, builder, formMapperContext, omitExtension);
       return;
     }
-    var schema = this.getSchema(field, formMapperContext);
+    var schema = this.getSchema(field, formMapperContext, omitExtension);
     builder.addPropertySchema(parameterName, schema);
   }
 
-  private Schema getSchema(FieldDefinition field, FormMapperContext formMapperContext) {
+  private Schema getSchema(
+      FieldDefinition field,
+      FormMapperContext formMapperContext,
+      Boolean omitExtension
+  ) {
     if (field.getTypes().size() > 1) {
       var schemaBuilder = new CombinedSchema.Builder().criterion(CombinedSchema.ONE_CRITERION);
       field.getTypes().stream()
-          .map(type -> this.getMemberSchema(type, field, formMapperContext))
+          .map(type -> this.getMemberSchema(type, field, formMapperContext, omitExtension))
           .forEach(schemaBuilder::subschema);
 
       return schemaBuilder.build();
     }
     var type = field.getTypes().get(0);
-    return this.getMemberSchema(type, field, formMapperContext);
+    return this.getMemberSchema(type, field, formMapperContext, omitExtension);
   }
 
   private Schema getMemberSchema(
       FieldType type,
       FieldDefinition fieldDefinition,
-      FormMapperContext formMapperContext
+      FormMapperContext formMapperContext,
+      Boolean omitExtension
   ) {
     var typeName = type.getType();
     if (type.isPrimitiveType()) {
@@ -154,8 +169,9 @@ private Schema getMemberSchema(
     } else {
       if (!formMapperContext.hasType(typeName)) {
         formMapperContext.addType(typeName);
-        var structureType = (ComplexStructureType) this.structureSchemaFinder.getStructureType(typeName);
-        var objectSchema = this.getObjectSchema(structureType, formMapperContext);
+        var structureType = (ComplexStructureType) this.structureSchemaFinder.getStructureType(
+            typeName);
+        var objectSchema = this.getObjectSchema(structureType, formMapperContext, omitExtension);
         formMapperContext.putSchema(typeName, objectSchema);
       }
       return new ReferenceSchema.Builder()
@@ -191,9 +207,10 @@ private Schema getPrimitiveSchema(String type, FieldDefinition fieldDefinition)
   private void mapArrayField(
       FieldDefinition field,
       ObjectSchema.Builder builder,
-      FormMapperContext formMapperContext
+      FormMapperContext formMapperContext,
+      Boolean omitExtension
   ) {
-    var itemSchema = this.getSchema(field, formMapperContext);
+    var itemSchema = this.getSchema(field, formMapperContext, omitExtension);
     builder.addPropertySchema(
         field.getName(),
         new ArraySchema.Builder().allItemSchema(itemSchema).build()
diff --git a/form-api/src/test/java/ai/stapi/formapi/FormEndpointTest.itShouldRespondWithJsonSchema.approved.txt b/form-api/src/test/java/ai/stapi/formapi/FormEndpointTest.itShouldRespondWithJsonSchema.approved.txt
index 13e88c10..9a71799f 100644
--- a/form-api/src/test/java/ai/stapi/formapi/FormEndpointTest.itShouldRespondWithJsonSchema.approved.txt
+++ b/form-api/src/test/java/ai/stapi/formapi/FormEndpointTest.itShouldRespondWithJsonSchema.approved.txt
@@ -1,4 +1,5 @@
 {
+  "formData" : { },
   "formSchema" : {
     "description" : "Generated command for creating StructureDefinition with all fields.",
     "title" : "CreateStructureDefinition",
@@ -14,14 +15,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedId",
             "title" : "id",
@@ -39,14 +32,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "period" : {
             "$ref" : "#/definitions/Period",
             "description" : "Time period during which identifier is/was valid for use.",
@@ -84,14 +69,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedBase64Binary",
             "title" : "base64Binary",
@@ -109,14 +86,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedBoolean",
             "title" : "boolean",
@@ -134,14 +103,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedCanonical",
             "title" : "canonical",
@@ -159,14 +120,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedCode",
             "title" : "code",
@@ -184,14 +137,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedDate",
             "title" : "date",
@@ -209,14 +154,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedDateTime",
             "title" : "dateTime",
@@ -234,14 +171,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedDecimal",
             "title" : "decimal",
@@ -259,14 +188,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedInstant",
             "title" : "instant",
@@ -284,14 +205,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedInteger",
             "title" : "integer",
@@ -309,14 +222,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedMarkdown",
             "title" : "markdown",
@@ -334,14 +239,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedOid",
             "title" : "oid",
@@ -359,14 +256,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedPositiveInt",
             "title" : "positiveInt",
@@ -384,14 +273,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedString",
             "title" : "string",
@@ -409,14 +290,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedTime",
             "title" : "time",
@@ -434,14 +307,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedUnsignedInt",
             "title" : "unsignedInt",
@@ -459,14 +324,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedUri",
             "title" : "uri",
@@ -484,14 +341,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedUrl",
             "title" : "url",
@@ -509,14 +358,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "description" : "Primitive value for BoxedUuid",
             "title" : "uuid",
@@ -542,14 +383,6 @@
               "title" : "Coding"
             }
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "text" : {
             "description" : "A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user.",
             "title" : "string",
@@ -572,14 +405,6 @@
             "description" : "A reference to a concept - e.g. the information is identified by its general class to the degree of precision found in the terminology.",
             "title" : "CodeableConcept"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "reference" : {
             "description" : "A reference to a resource the provides exact details about the information being referenced.",
             "title" : "Reference",
@@ -607,14 +432,6 @@
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "system" : {
             "description" : "The identification of the code system that defines the meaning of the symbol in the code.",
             "title" : "uri",
@@ -658,14 +475,6 @@
               "title" : "DataRequirementDateFilter"
             }
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "limit" : {
             "description" : "Specifies a maximum number of results that are required (uses the _count search parameter).",
             "title" : "positiveInt",
@@ -728,14 +537,6 @@ The value of mustSupport SHALL be a FHIRPath resolveable on the type of the Data
               "title" : "Coding"
             }
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "path" : {
             "description" : "The code-valued attribute of the filter. The specified path SHALL be a FHIRPath resolveable on the specified type of the DataRequirement, and SHALL consist only of identifiers, constant indexers, and .resolve(). The path is allowed to contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to traverse multiple-cardinality sub-elements (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details). Note that the index must be an integer constant. The path must resolve to an element of type code, Coding, or CodeableConcept.",
             "title" : "string",
@@ -763,14 +564,6 @@ The value of mustSupport SHALL be a FHIRPath resolveable on the type of the Data
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "path" : {
             "description" : "The date-valued attribute of the filter. The specified path SHALL be a FHIRPath resolveable on the specified type of the DataRequirement, and SHALL consist only of identifiers, constant indexers, and .resolve(). The path is allowed to contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to traverse multiple-cardinality sub-elements (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details). Note that the index must be an integer constant. The path must resolve to an element of type date, dateTime, Period, Schedule, or Timing.",
             "title" : "string",
@@ -813,14 +606,6 @@ The value of mustSupport SHALL be a FHIRPath resolveable on the type of the Data
             "title" : "code",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "path" : {
             "description" : "The attribute of the sort. The specified path must be resolvable from the type of the required data. The path is allowed to contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to traverse multiple-cardinality sub-elements. Note that the index must be an integer constant.",
             "title" : "string",
@@ -849,14 +634,6 @@ The value of mustSupport SHALL be a FHIRPath resolveable on the type of the Data
             "title" : "code",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "system" : {
             "description" : "The identification of the system that provides the coded form of the unit.",
             "title" : "uri",
@@ -1064,14 +841,6 @@ The value of mustSupport SHALL be a FHIRPath resolveable on the type of the Data
               "title" : "ElementDefinitionExample"
             }
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "fixed" : {
             "oneOf" : [ {
               "$ref" : "#/definitions/BoxedBase64Binary",
@@ -1305,16 +1074,6 @@ The value of mustSupport SHALL be a FHIRPath resolveable on the type of the Data
               "title" : "BoxedUnsignedInt"
             } ]
           },
-          "modifierExtension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
-
-Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).",
-              "title" : "Extension"
-            }
-          },
           "mustSupport" : {
             "description" : "If true, implementations that produce or consume resources SHALL provide \"support\" for the element in some meaningful way.  If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.",
             "title" : "boolean",
@@ -1779,14 +1538,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "max" : {
             "description" : "Maximum cardinality of the base element identified by the path.",
             "title" : "string",
@@ -1820,14 +1571,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "strength" : {
             "description" : "Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.",
             "title" : "code",
@@ -1856,14 +1599,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "human" : {
             "description" : "Text that can be used to describe the constraint in messages identifying that the constraint has been violated.",
             "title" : "string",
@@ -1907,14 +1642,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "label" : {
             "description" : "Describes the purpose of this example amoung the set of examples.",
             "title" : "string",
@@ -2053,14 +1780,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "identity" : {
             "description" : "An internal reference to the definition of a mapping.",
             "title" : "id",
@@ -2102,14 +1821,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
               "title" : "ElementDefinitionSlicingDiscriminator"
             }
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "ordered" : {
             "description" : "If the matching elements have to occur in the same order as defined in the profile.",
             "title" : "boolean",
@@ -2133,14 +1844,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "path" : {
             "description" : "A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.",
             "title" : "string",
@@ -2182,14 +1885,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "StructureDefinition",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "profile" : {
             "type" : "array",
             "items" : {
@@ -2242,14 +1937,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "language" : {
             "description" : "The media type of the language for the expression.",
             "title" : "code",
@@ -2268,159 +1955,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
         },
         "required" : [ "language" ]
       },
-      "Extension" : {
-        "description" : "Base StructureDefinition for Extension Type: Optional Extension Element - found in all resources.",
-        "title" : "Extension",
-        "type" : "object",
-        "properties" : {
-          "id" : {
-            "description" : "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
-            "title" : "string",
-            "type" : "string"
-          },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
-          "url" : {
-            "description" : "Source of the definition for the extension code - a logical name or a URL.",
-            "title" : "string",
-            "type" : "string"
-          },
-          "value" : {
-            "oneOf" : [ {
-              "$ref" : "#/definitions/BoxedBase64Binary",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedBase64Binary"
-            }, {
-              "$ref" : "#/definitions/BoxedBoolean",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedBoolean"
-            }, {
-              "$ref" : "#/definitions/BoxedCanonical",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedCanonical"
-            }, {
-              "$ref" : "#/definitions/BoxedCode",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedCode"
-            }, {
-              "$ref" : "#/definitions/BoxedDate",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedDate"
-            }, {
-              "$ref" : "#/definitions/BoxedDateTime",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedDateTime"
-            }, {
-              "$ref" : "#/definitions/BoxedDecimal",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedDecimal"
-            }, {
-              "$ref" : "#/definitions/BoxedId",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedId"
-            }, {
-              "$ref" : "#/definitions/BoxedInstant",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedInstant"
-            }, {
-              "$ref" : "#/definitions/BoxedInteger",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedInteger"
-            }, {
-              "$ref" : "#/definitions/BoxedMarkdown",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedMarkdown"
-            }, {
-              "$ref" : "#/definitions/BoxedOid",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedOid"
-            }, {
-              "$ref" : "#/definitions/BoxedPositiveInt",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedPositiveInt"
-            }, {
-              "$ref" : "#/definitions/BoxedString",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedString"
-            }, {
-              "$ref" : "#/definitions/BoxedTime",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedTime"
-            }, {
-              "$ref" : "#/definitions/BoxedUnsignedInt",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedUnsignedInt"
-            }, {
-              "$ref" : "#/definitions/BoxedUri",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedUri"
-            }, {
-              "$ref" : "#/definitions/BoxedUrl",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedUrl"
-            }, {
-              "$ref" : "#/definitions/BoxedUuid",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "BoxedUuid"
-            }, {
-              "$ref" : "#/definitions/CodeableConcept",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "CodeableConcept"
-            }, {
-              "$ref" : "#/definitions/CodeableReference",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "CodeableReference"
-            }, {
-              "$ref" : "#/definitions/Coding",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "Coding"
-            }, {
-              "$ref" : "#/definitions/DataRequirement",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "DataRequirement"
-            }, {
-              "$ref" : "#/definitions/Expression",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "Expression"
-            }, {
-              "$ref" : "#/definitions/Identifier",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "Identifier"
-            }, {
-              "$ref" : "#/definitions/ParameterDefinition",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "ParameterDefinition"
-            }, {
-              "$ref" : "#/definitions/Period",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "Period"
-            }, {
-              "$ref" : "#/definitions/Quantity",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "Quantity"
-            }, {
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "Reference",
-              "type" : "string"
-            }, {
-              "$ref" : "#/definitions/SimpleQuantity",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "SimpleQuantity"
-            }, {
-              "$ref" : "#/definitions/TriggerDefinition",
-              "description" : "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
-              "title" : "TriggerDefinition"
-            } ]
-          }
-        },
-        "required" : [ "url" ]
-      },
       "Meta" : {
         "description" : "Base StructureDefinition for Meta Type: The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.",
         "title" : "Meta",
@@ -2436,14 +1970,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "id",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "lastUpdated" : {
             "description" : "When the resource last changed - e.g. when the version changed.",
             "title" : "instant",
@@ -2495,14 +2021,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "xhtml",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "status" : {
             "description" : "The status of the narrative - whether it's entirely generated (from just the defined data or the extensions too), or whether a human authored it and it may contain additional data.",
             "title" : "code",
@@ -2526,14 +2044,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "max" : {
             "description" : "The maximum number of times this element is permitted to appear in the request or response.",
             "title" : "string",
@@ -2582,14 +2092,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "dateTime",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "start" : {
             "description" : "The start of the period. The boundary is inclusive.",
             "title" : "dateTime",
@@ -2617,14 +2119,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "code",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "system" : {
             "description" : "The identification of the system that provides the coded form of the unit.",
             "title" : "uri",
@@ -2652,14 +2146,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "high" : {
             "$ref" : "#/definitions/Quantity",
             "description" : "The high limit. The boundary is inclusive.",
@@ -2699,46 +2185,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
           }
         }
       },
-      "SimpleQuantity" : {
-        "description" : "A fixed quantity (no comparator)",
-        "title" : "SimpleQuantity",
-        "type" : "object",
-        "properties" : {
-          "id" : {
-            "description" : "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
-            "title" : "string",
-            "type" : "string"
-          },
-          "code" : {
-            "description" : "A computer processable form of the unit in some unit representation system.",
-            "title" : "code",
-            "type" : "string"
-          },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
-          "system" : {
-            "description" : "The identification of the system that provides the coded form of the unit.",
-            "title" : "uri",
-            "type" : "string"
-          },
-          "unit" : {
-            "description" : "A human-readable form of the unit.",
-            "title" : "string",
-            "type" : "string"
-          },
-          "value" : {
-            "description" : "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
-            "title" : "decimal",
-            "type" : "number"
-          }
-        }
-      },
       "StructureDefinitionContext" : {
         "description" : "Type for anonymous field contained in StructureDefinition",
         "title" : "StructureDefinitionContext",
@@ -2754,24 +2200,6 @@ When pattern[x] is used to constrain a complex object, it means that each proper
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
-          "modifierExtension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
-
-Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).",
-              "title" : "Extension"
-            }
-          },
           "type" : {
             "description" : "Defines how to interpret the expression that defines what the context of the extension is.",
             "title" : "code",
@@ -2797,24 +2225,6 @@ Modifier extensions SHALL NOT change the meaning of any elements on Resource or
               "description" : "Captures constraints on each element within the resource.",
               "title" : "ElementDefinition"
             }
-          },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
-          "modifierExtension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
-
-Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).",
-              "title" : "Extension"
-            }
           }
         },
         "required" : [ "element" ]
@@ -2834,29 +2244,11 @@ Modifier extensions SHALL NOT change the meaning of any elements on Resource or
             "title" : "string",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "identity" : {
             "description" : "An Internal id that is used to identify this mapping set when specific mappings are made.",
             "title" : "id",
             "type" : "string"
           },
-          "modifierExtension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
-
-Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).",
-              "title" : "Extension"
-            }
-          },
           "name" : {
             "description" : "A name for the specification that is being mapped to.",
             "title" : "string",
@@ -2887,24 +2279,6 @@ Modifier extensions SHALL NOT change the meaning of any elements on Resource or
               "description" : "Captures constraints on each element within the resource.",
               "title" : "ElementDefinition"
             }
-          },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
-          "modifierExtension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
-
-Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).",
-              "title" : "Extension"
-            }
           }
         },
         "required" : [ "element" ]
@@ -2932,24 +2306,6 @@ Modifier extensions SHALL NOT change the meaning of any elements on Resource or
               "type" : "string"
             }
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
-          "modifierExtension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
-
-Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).",
-              "title" : "Extension"
-            }
-          },
           "repeat" : {
             "$ref" : "#/definitions/TimingRepeat",
             "description" : "A set of rules that describe when the event is scheduled.",
@@ -3015,14 +2371,6 @@ Modifier extensions SHALL NOT change the meaning of any elements on Resource or
             "title" : "code",
             "type" : "string"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "frequency" : {
             "description" : "The number of times to repeat the action within the specified period. If frequencyMax is present, this element indicates the lower bound of the allowed range of the frequency.",
             "title" : "positiveInt",
@@ -3094,14 +2442,6 @@ Modifier extensions SHALL NOT change the meaning of any elements on Resource or
               "title" : "DataRequirement"
             }
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "name" : {
             "description" : "A formal name for the event. This may be an absolute URI that identifies the event formally (e.g. from a trigger registry), or a simple relative URI that identifies the event in a local context.",
             "title" : "string",
@@ -3145,14 +2485,6 @@ Modifier extensions SHALL NOT change the meaning of any elements on Resource or
             "description" : "A code that identifies the type of context being specified by this usage context.",
             "title" : "Coding"
           },
-          "extension" : {
-            "type" : "array",
-            "items" : {
-              "$ref" : "#/definitions/Extension",
-              "description" : "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
-              "title" : "Extension"
-            }
-          },
           "value" : {
             "oneOf" : [ {
               "$ref" : "#/definitions/CodeableConcept",
@@ -3242,14 +2574,6 @@ Modifier extensions SHALL NOT change the meaning of any elements on Resource or
         "title" : "boolean",
         "type" : "boolean"
       },
-      "extension" : {
-        "type" : "array",
-        "items" : {
-          "$ref" : "#/definitions/Extension",
-          "description" : "",
-          "title" : "Extension"
-        }
-      },
       "fhirVersion" : {
         "description" : "",
         "title" : "code",
@@ -3307,14 +2631,6 @@ Modifier extensions SHALL NOT change the meaning of any elements on Resource or
         "description" : "",
         "title" : "Meta"
       },
-      "modifierExtension" : {
-        "type" : "array",
-        "items" : {
-          "$ref" : "#/definitions/Extension",
-          "description" : "",
-          "title" : "Extension"
-        }
-      },
       "name" : {
         "description" : "",
         "title" : "string",