@itwin/rpcinterface-full-stack-tests 5.1.0-dev.58 → 5.1.0-dev.60

package/lib/dist/bundled-tests.js

@@ -90622,8 +90622,11 @@ class SchemaReadHelper {
      * calling getCachedSchema on the context.
      * @param schema The Schema to populate
      * @param rawSchema The serialized data to use to populate the Schema.
+     * @param addSchemaToCache Optional parameter that indicates if the schema should be added to the SchemaContext.
+     * The default is true. If false, the schema loading will not begin asynchronously in the background because the
+     * schema promise must be added to the context. In this case, only the SchemaInfo is returned.
      */
-    async readSchemaInfo(schema, rawSchema) {
+    async readSchemaInfo(schema, rawSchema, addSchemaToCache = true) {
         // Ensure context matches schema context
         if (schema.context) {
             if (this._context !== schema.context)
@@ -90636,15 +90639,15 @@ class SchemaReadHelper {
         // Loads all of the properties on the Schema object
         await schema.fromJSON(this._parser.parseSchema());
         this._schema = schema;
-        const schemaInfoReferences = [];
-        const schemaInfo = { schemaKey: schema.schemaKey, alias: schema.alias, references: schemaInfoReferences };
+        const schemaReferences = [];
+        const schemaInfo = { schemaKey: schema.schemaKey, alias: schema.alias, references: schemaReferences };
         for (const reference of this._parser.getReferences()) {
             const refKey = new _SchemaKey__WEBPACK_IMPORTED_MODULE_5__.SchemaKey(reference.name, _SchemaKey__WEBPACK_IMPORTED_MODULE_5__.ECVersion.fromString(reference.version));
-            schemaInfoReferences.push({ schemaKey: refKey });
+            schemaReferences.push({ schemaKey: refKey });
         }
         this._schemaInfo = schemaInfo;
         // Need to add this schema to the context to be able to locate schemaItems within the context.
-        if (!this._context.schemaExists(schema.schemaKey)) {
+        if (addSchemaToCache && !this._context.schemaExists(schema.schemaKey)) {
             await this._context.addSchemaPromise(schemaInfo, schema, this.loadSchema(schemaInfo, schema));
         }
         return schemaInfo;
@@ -90653,33 +90656,53 @@ class SchemaReadHelper {
      * Populates the given Schema from a serialized representation.
      * @param schema The Schema to populate
      * @param rawSchema The serialized data to use to populate the Schema.
+     * @param addSchemaToCache Optional parameter that indicates if the schema should be added to the SchemaContext.
+     * The default is true. If false, the schema will be loaded directly by this method and not from the context's schema cache.
      */
-    async readSchema(schema, rawSchema) {
+    async readSchema(schema, rawSchema, addSchemaToCache = true) {
         if (!this._schemaInfo) {
-            await this.readSchemaInfo(schema, rawSchema);
+            await this.readSchemaInfo(schema, rawSchema, addSchemaToCache);
+        }
+        // If not adding schema to cache (occurs in readSchemaInfo), we must load the schema here
+        if (!addSchemaToCache) {
+            const loadedSchema = await this.loadSchema(this._schemaInfo, schema);
+            if (undefined === loadedSchema)
+                throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.UnableToLoadSchema, `Could not load schema ${schema.schemaKey.toString()}`);
+            return loadedSchema;
         }
         const cachedSchema = await this._context.getCachedSchema(this._schemaInfo.schemaKey, _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaMatchType.Latest);
         if (undefined === cachedSchema)
             throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.UnableToLoadSchema, `Could not load schema ${schema.schemaKey.toString()}`);
         return cachedSchema;
     }
+    /**
+     * Called when a SchemaItem has been successfully loaded by the Helper. The default implementation simply
+     * checks if the schema item is undefined. An implementation of the helper may choose to partially load
+     * a schema item in which case this method would indicate if the item has been fully loaded.
+     * @param schemaItem The SchemaItem to check.
+     * @returns True if the SchemaItem has been fully loaded, false otherwise.
+     */
+    isSchemaItemLoaded(schemaItem) {
+        return schemaItem !== undefined;
+    }
     /* Finish loading the rest of the schema */
     async loadSchema(schemaInfo, schema) {
         // Verify that there are no schema reference cycles, this will start schema loading by loading their headers
         (await _utils_SchemaGraph__WEBPACK_IMPORTED_MODULE_8__.SchemaGraph.generateGraph(schemaInfo, this._context)).throwIfCycles();
         for (const reference of schemaInfo.references) {
-            await this.loadSchemaReference(schemaInfo, reference.schemaKey);
+            await this.loadSchemaReference(schema, reference.schemaKey);
         }
         if (this._visitorHelper)
             await this._visitorHelper.visitSchema(schema, false);
         // Load all schema items
         for (const [itemName, itemType, rawItem] of this._parser.getItems()) {
-            // Make sure the item has not already been read. No need to check the SchemaContext because all SchemaItems are added to a Schema,
+            // Make sure the item has not already been loaded. No need to check the SchemaContext because all SchemaItems are added to a Schema,
             // which would be found when adding to the context.
-            if (await schema.getItem(itemName) !== undefined)
+            const schemaItem = await schema.getItem(itemName);
+            if (this.isSchemaItemLoaded(schemaItem))
                 continue;
             const loadedItem = await this.loadSchemaItem(schema, itemName, itemType, rawItem);
-            if (loadedItem && this._visitorHelper) {
+            if (this.isSchemaItemLoaded(loadedItem) && this._visitorHelper) {
                 await this._visitorHelper.visitSchemaPart(loadedItem);
             }
         }
@@ -90710,12 +90733,8 @@ class SchemaReadHelper {
             this._visitorHelper.visitSchemaSync(schema, false);
         // Load all schema items
         for (const [itemName, itemType, rawItem] of this._parser.getItems()) {
-            // Make sure the item has not already been read. No need to check the SchemaContext because all SchemaItems are added to a Schema,
-            // which would be found when adding to the context.
-            if (schema.getItemSync(itemName) !== undefined)
-                continue;
             const loadedItem = this.loadSchemaItemSync(schema, itemName, itemType, rawItem);
-            if (loadedItem && this._visitorHelper) {
+            if (this.isSchemaItemLoaded(loadedItem) && this._visitorHelper) {
                 this._visitorHelper.visitSchemaPartSync(loadedItem);
             }
         }
@@ -90728,12 +90747,14 @@ class SchemaReadHelper {
      * Ensures that the schema references can be located and adds them to the schema.
      * @param ref The object to read the SchemaReference's props from.
      */
-    async loadSchemaReference(schemaInfo, refKey) {
+    async loadSchemaReference(schema, refKey) {
         const refSchema = await this._context.getSchema(refKey, _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaMatchType.LatestWriteCompatible);
         if (undefined === refSchema)
-            throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.UnableToLocateSchema, `Could not locate the referenced schema, ${refKey.name}.${refKey.version.toString()}, of ${schemaInfo.schemaKey.name}`);
-        await this._schema.addReference(refSchema);
-        const results = this.validateSchemaReferences(this._schema);
+            throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.UnableToLocateSchema, `Could not locate the referenced schema, ${refKey.name}.${refKey.version.toString()}, of ${schema.schemaKey.name}`);
+        if (schema.references.find((ref) => ref.schemaKey.matches(refSchema.schemaKey)))
+            return refSchema;
+        await schema.addReference(refSchema);
+        const results = this.validateSchemaReferences(schema);
         let errorMessage = "";
         for (const result of results) {
             errorMessage += `${result}\r\n`;
@@ -90741,6 +90762,7 @@ class SchemaReadHelper {
         if (errorMessage) {
             throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `${errorMessage}`);
         }
+        return refSchema;
     }
     /**
      * Ensures that the schema references can be located and adds them to the schema.
@@ -90790,73 +90812,97 @@ class SchemaReadHelper {
      * @param schemaItemObject The Object to populate the SchemaItem with.
      */
     async loadSchemaItem(schema, name, itemType, schemaItemObject) {
-        let schemaItem;
+        let schemaItem = await schema.getItem(name);
+        if (this.isSchemaItemLoaded(schemaItem)) {
+            return schemaItem;
+        }
         switch ((0,_ECObjects__WEBPACK_IMPORTED_MODULE_1__.parseSchemaItemType)(itemType)) {
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.EntityClass:
-                schemaItem = await schema.createEntityClass(name);
-                await this.loadEntityClass(schemaItem, schemaItemObject);
+                schemaItem = schemaItem || await schema.createEntityClass(name);
+                schemaItemObject && await this.loadEntityClass(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.StructClass:
-                schemaItem = await schema.createStructClass(name);
-                const structProps = this._parser.parseStructClass(schemaItemObject);
-                await this.loadClass(schemaItem, structProps, schemaItemObject);
+                schemaItem = schemaItem || await schema.createStructClass(name);
+                const structProps = schemaItemObject && this._parser.parseStructClass(schemaItemObject);
+                structProps && await this.loadClass(schemaItem, structProps, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Mixin:
-                schemaItem = await schema.createMixinClass(name);
-                await this.loadMixin(schemaItem, schemaItemObject);
+                schemaItem = schemaItem || await schema.createMixinClass(name);
+                schemaItemObject && await this.loadMixin(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.CustomAttributeClass:
-                schemaItem = await schema.createCustomAttributeClass(name);
-                const caClassProps = this._parser.parseCustomAttributeClass(schemaItemObject);
-                await this.loadClass(schemaItem, caClassProps, schemaItemObject);
+                schemaItem = schemaItem || await schema.createCustomAttributeClass(name);
+                const caClassProps = schemaItemObject && this._parser.parseCustomAttributeClass(schemaItemObject);
+                caClassProps && await this.loadClass(schemaItem, caClassProps, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.RelationshipClass:
-                schemaItem = await schema.createRelationshipClass(name);
-                await this.loadRelationshipClass(schemaItem, schemaItemObject);
+                schemaItem = schemaItem || await schema.createRelationshipClass(name);
+                schemaItemObject && await this.loadRelationshipClass(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.KindOfQuantity:
-                schemaItem = await schema.createKindOfQuantity(name);
-                await this.loadKindOfQuantity(schemaItem, schemaItemObject);
+                schemaItem = schemaItem || await schema.createKindOfQuantity(name);
+                schemaItemObject && await this.loadKindOfQuantity(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Unit:
-                schemaItem = await schema.createUnit(name);
-                await this.loadUnit(schemaItem, schemaItemObject);
+                schemaItem = schemaItem || await schema.createUnit(name);
+                schemaItemObject && await this.loadUnit(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Constant:
-                schemaItem = await schema.createConstant(name);
-                await this.loadConstant(schemaItem, schemaItemObject);
+                schemaItem = schemaItem || await schema.createConstant(name);
+                schemaItemObject && await this.loadConstant(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.InvertedUnit:
-                schemaItem = await schema.createInvertedUnit(name);
-                await this.loadInvertedUnit(schemaItem, schemaItemObject);
+                schemaItem = schemaItem || await schema.createInvertedUnit(name);
+                schemaItemObject && await this.loadInvertedUnit(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Format:
-                schemaItem = await schema.createFormat(name);
-                await this.loadFormat(schemaItem, schemaItemObject);
+                schemaItem = schemaItem || await schema.createFormat(name);
+                schemaItemObject && await this.loadFormat(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Phenomenon:
-                schemaItem = await schema.createPhenomenon(name);
-                const phenomenonProps = this._parser.parsePhenomenon(schemaItemObject);
-                await schemaItem.fromJSON(phenomenonProps);
+                schemaItem = schemaItem || await schema.createPhenomenon(name);
+                const phenomenonProps = schemaItemObject && this._parser.parsePhenomenon(schemaItemObject);
+                phenomenonProps && await schemaItem.fromJSON(phenomenonProps);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.UnitSystem:
-                schemaItem = await schema.createUnitSystem(name);
-                await schemaItem.fromJSON(this._parser.parseUnitSystem(schemaItemObject));
+                schemaItem = schemaItem || await schema.createUnitSystem(name);
+                schemaItemObject && await schemaItem.fromJSON(this._parser.parseUnitSystem(schemaItemObject));
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.PropertyCategory:
-                schemaItem = await schema.createPropertyCategory(name);
-                const propertyCategoryProps = this._parser.parsePropertyCategory(schemaItemObject);
-                await schemaItem.fromJSON(propertyCategoryProps);
+                schemaItem = schemaItem || await schema.createPropertyCategory(name);
+                const propertyCategoryProps = schemaItemObject && this._parser.parsePropertyCategory(schemaItemObject);
+                propertyCategoryProps && schemaItemObject && await schemaItem.fromJSON(propertyCategoryProps);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Enumeration:
-                schemaItem = await schema.createEnumeration(name);
-                const enumerationProps = this._parser.parseEnumeration(schemaItemObject);
-                await schemaItem.fromJSON(enumerationProps);
+                schemaItem = schemaItem || await schema.createEnumeration(name);
+                const enumerationProps = schemaItemObject && this._parser.parseEnumeration(schemaItemObject);
+                enumerationProps && await schemaItem.fromJSON(enumerationProps);
                 break;
             // NOTE: we are being permissive here and allowing unknown types to silently fail. Not sure if we want to hard fail or just do a basic deserialization
         }
         return schemaItem;
     }
+    /**
+     * Load the customAttribute class dependencies for a set of CustomAttribute objects and add
+     * them to a given custom attribute container.
+     * @param container The CustomAttributeContainer that each CustomAttribute will be added to.
+     * @param customAttributes An iterable set of parsed CustomAttribute objects.
+     */
+    async loadCustomAttributes(container, caProviders) {
+        for (const providerTuple of caProviders) {
+            // First tuple entry is the CA class name.
+            const caClass = await this.findSchemaItem(providerTuple[0]);
+            // If custom attribute exist within the context and is referenced, validate the reference is defined in the container's schema
+            if (caClass && caClass.key.schemaName !== container.schema.name &&
+                !container.schema.getReferenceSync(caClass.key.schemaName)) {
+                throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `Unable to load custom attribute ${caClass.fullName} from container ${container.fullName}, ${caClass.key.schemaName} reference not defined`);
+            }
+            // Second tuple entry ia a function that provides the CA instance.
+            const provider = providerTuple[1];
+            const customAttribute = provider(caClass);
+            container.addCustomAttribute(customAttribute);
+        }
+    }
     /**
      * Given the schema item object, the anticipated type and the name a schema item is created and loaded into the schema provided.
      * @param schema The Schema the SchemaItem to.
@@ -90865,66 +90911,69 @@ class SchemaReadHelper {
      * @param schemaItemObject The Object to populate the SchemaItem with.
      */
     loadSchemaItemSync(schema, name, itemType, schemaItemObject) {
-        let schemaItem;
+        let schemaItem = schema.getItemSync(name);
+        if (this.isSchemaItemLoaded(schemaItem)) {
+            return schemaItem;
+        }
         switch ((0,_ECObjects__WEBPACK_IMPORTED_MODULE_1__.parseSchemaItemType)(itemType)) {
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.EntityClass:
-                schemaItem = schema.createEntityClassSync(name);
+                schemaItem = schemaItem || schema.createEntityClassSync(name);
                 this.loadEntityClassSync(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.StructClass:
-                schemaItem = schema.createStructClassSync(name);
+                schemaItem = schemaItem || schema.createStructClassSync(name);
                 const structProps = this._parser.parseStructClass(schemaItemObject);
                 this.loadClassSync(schemaItem, structProps, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Mixin:
-                schemaItem = schema.createMixinClassSync(name);
+                schemaItem = schemaItem || schema.createMixinClassSync(name);
                 this.loadMixinSync(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.CustomAttributeClass:
-                schemaItem = schema.createCustomAttributeClassSync(name);
+                schemaItem = schemaItem || schema.createCustomAttributeClassSync(name);
                 const caClassProps = this._parser.parseCustomAttributeClass(schemaItemObject);
                 this.loadClassSync(schemaItem, caClassProps, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.RelationshipClass:
-                schemaItem = schema.createRelationshipClassSync(name);
+                schemaItem = schemaItem || schema.createRelationshipClassSync(name);
                 this.loadRelationshipClassSync(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.KindOfQuantity:
-                schemaItem = schema.createKindOfQuantitySync(name);
+                schemaItem = schemaItem || schema.createKindOfQuantitySync(name);
                 this.loadKindOfQuantitySync(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Unit:
-                schemaItem = schema.createUnitSync(name);
+                schemaItem = schemaItem || schema.createUnitSync(name);
                 this.loadUnitSync(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Constant:
-                schemaItem = schema.createConstantSync(name);
+                schemaItem = schemaItem || schema.createConstantSync(name);
                 this.loadConstantSync(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.InvertedUnit:
-                schemaItem = schema.createInvertedUnitSync(name);
+                schemaItem = schemaItem || schema.createInvertedUnitSync(name);
                 this.loadInvertedUnitSync(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Format:
-                schemaItem = schema.createFormatSync(name);
+                schemaItem = schemaItem || schema.createFormatSync(name);
                 this.loadFormatSync(schemaItem, schemaItemObject);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Phenomenon:
-                schemaItem = schema.createPhenomenonSync(name);
+                schemaItem = schemaItem || schema.createPhenomenonSync(name);
                 const phenomenonProps = this._parser.parsePhenomenon(schemaItemObject);
                 schemaItem.fromJSONSync(phenomenonProps);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.UnitSystem:
-                schemaItem = schema.createUnitSystemSync(name);
+                schemaItem = schemaItem || schema.createUnitSystemSync(name);
                 schemaItem.fromJSONSync(this._parser.parseUnitSystem(schemaItemObject));
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.PropertyCategory:
-                schemaItem = schema.createPropertyCategorySync(name);
+                schemaItem = schemaItem || schema.createPropertyCategorySync(name);
                 const propertyCategoryProps = this._parser.parsePropertyCategory(schemaItemObject);
                 schemaItem.fromJSONSync(propertyCategoryProps);
                 break;
             case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Enumeration:
-                schemaItem = schema.createEnumerationSync(name);
+                schemaItem = schemaItem || schema.createEnumerationSync(name);
                 const enumerationProps = this._parser.parseEnumeration(schemaItemObject);
                 schemaItem.fromJSONSync(enumerationProps);
                 break;
@@ -90972,7 +91021,7 @@ class SchemaReadHelper {
             const foundItem = this._parser.findItem(itemName);
             if (foundItem) {
                 schemaItem = await this.loadSchemaItem(this._schema, ...foundItem);
-                if (!skipVisitor && schemaItem && this._visitorHelper) {
+                if (!skipVisitor && this.isSchemaItemLoaded(schemaItem) && this._visitorHelper) {
                     await this._visitorHelper.visitSchemaPart(schemaItem);
                 }
                 if (loadCallBack && schemaItem)
@@ -91005,7 +91054,7 @@ class SchemaReadHelper {
             const foundItem = this._parser.findItem(itemName);
             if (foundItem) {
                 schemaItem = this.loadSchemaItemSync(this._schema, ...foundItem);
-                if (!skipVisitor && schemaItem && this._visitorHelper) {
+                if (!skipVisitor && this.isSchemaItemLoaded(schemaItem) && this._visitorHelper) {
                     this._visitorHelper.visitSchemaPartSync(schemaItem);
                 }
                 if (loadCallBack && schemaItem)
@@ -91155,7 +91204,7 @@ class SchemaReadHelper {
      */
     async loadClass(classObj, classProps, rawClass) {
         const baseClassLoaded = async (baseClass) => {
-            if (this._visitorHelper)
+            if (this._visitorHelper && this.isSchemaItemLoaded(baseClass))
                 await this._visitorHelper.visitSchemaPart(baseClass);
         };
         // Load base class first
@@ -91178,7 +91227,7 @@ class SchemaReadHelper {
      */
     loadClassSync(classObj, classProps, rawClass) {
         const baseClassLoaded = async (baseClass) => {
-            if (this._visitorHelper)
+            if (this._visitorHelper && this.isSchemaItemLoaded(baseClass))
                 this._visitorHelper.visitSchemaPartSync(baseClass);
         };
         // Load base class first
@@ -91229,7 +91278,7 @@ class SchemaReadHelper {
     async loadMixin(mixin, rawMixin) {
         const mixinProps = this._parser.parseMixin(rawMixin);
         const appliesToLoaded = async (appliesToClass) => {
-            if (this._visitorHelper)
+            if (this._visitorHelper && this.isSchemaItemLoaded(appliesToClass))
                 await this._visitorHelper.visitSchemaPart(appliesToClass);
         };
         await this.findSchemaItem(mixinProps.appliesTo, true, appliesToLoaded);
@@ -91243,7 +91292,7 @@ class SchemaReadHelper {
     loadMixinSync(mixin, rawMixin) {
         const mixinProps = this._parser.parseMixin(rawMixin);
         const appliesToLoaded = async (appliesToClass) => {
-            if (this._visitorHelper)
+            if (this._visitorHelper && this.isSchemaItemLoaded(appliesToClass))
                 await this._visitorHelper.visitSchemaPart(appliesToClass);
         };
         this.findSchemaItemSync(mixinProps.appliesTo, true, appliesToLoaded);
@@ -91439,27 +91488,6 @@ class SchemaReadHelper {
         propertyObj.fromJSONSync(props);
         this.loadCustomAttributesSync(propertyObj, this._parser.getPropertyCustomAttributeProviders(rawProperty));
     }
-    /**
-     * Load the customAttribute class dependencies for a set of CustomAttribute objects and add
-     * them to a given custom attribute container.
-     * @param container The CustomAttributeContainer that each CustomAttribute will be added to.
-     * @param customAttributes An iterable set of parsed CustomAttribute objects.
-     */
-    async loadCustomAttributes(container, caProviders) {
-        for (const providerTuple of caProviders) {
-            // First tuple entry is the CA class name.
-            const caClass = await this.findSchemaItem(providerTuple[0]);
-            // If custom attribute exist within the context and is referenced, validate the reference is defined in the container's schema
-            if (caClass && caClass.key.schemaName !== container.schema.name &&
-                !container.schema.getReferenceSync(caClass.key.schemaName)) {
-                throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `Unable to load custom attribute ${caClass.fullName} from container ${container.fullName}, ${caClass.key.schemaName} reference not defined`);
-            }
-            // Second tuple entry ia a function that provides the CA instance.
-            const provider = providerTuple[1];
-            const customAttribute = provider(caClass);
-            container.addCustomAttribute(customAttribute);
-        }
-    }
     /**
      * Load the customAttribute class dependencies for a set of CustomAttribute objects and add them to a given custom attribute container.
      * @param container The CustomAttributeContainer that each CustomAttribute will be added to.
@@ -92813,8 +92841,8 @@ class XmlParser extends _AbstractParser__WEBPACK_IMPORTED_MODULE_5__.AbstractPar
         }
     }
     parsePrimitiveProperty(xmlElement) {
-        const propertyProps = this.getPrimitiveOrEnumPropertyBaseProps(xmlElement);
         const typeName = this.getPropertyTypeName(xmlElement);
+        const propertyProps = this.getPrimitiveOrEnumPropertyBaseProps(xmlElement, typeName);
         const primitivePropertyProps = { ...propertyProps, typeName };
         return primitivePropertyProps;
     }
@@ -92826,7 +92854,7 @@ class XmlParser extends _AbstractParser__WEBPACK_IMPORTED_MODULE_5__.AbstractPar
     }
     parsePrimitiveArrayProperty(xmlElement) {
         const typeName = this.getPropertyTypeName(xmlElement);
-        const propertyProps = this.getPrimitiveOrEnumPropertyBaseProps(xmlElement);
+        const propertyProps = this.getPrimitiveOrEnumPropertyBaseProps(xmlElement, typeName);
         const minAndMaxOccurs = this.getPropertyMinAndMaxOccurs(xmlElement);
         return {
             ...propertyProps,
@@ -93101,14 +93129,23 @@ class XmlParser extends _AbstractParser__WEBPACK_IMPORTED_MODULE_5__.AbstractPar
             return rawTypeName;
         return this.getQualifiedTypeName(rawTypeName);
     }
-    getPrimitiveOrEnumPropertyBaseProps(xmlElement) {
+    getPrimitiveOrEnumPropertyBaseProps(xmlElement, typeName) {
+        const primitiveType = (0,_ECObjects__WEBPACK_IMPORTED_MODULE_1__.parsePrimitiveType)(typeName);
         const propertyProps = this.getPropertyProps(xmlElement);
         const propName = propertyProps.name;
         const extendedTypeName = this.getOptionalAttribute(xmlElement, "extendedTypeName");
         const minLength = this.getOptionalIntAttribute(xmlElement, "minimumLength", `The ECProperty ${this._currentItemFullName}.${propName} has an invalid 'minimumLength' attribute. It should be a numeric value.`);
         const maxLength = this.getOptionalIntAttribute(xmlElement, "maximumLength", `The ECProperty ${this._currentItemFullName}.${propName} has an invalid 'maximumLength' attribute. It should be a numeric value.`);
-        const minValue = this.getOptionalIntAttribute(xmlElement, "minimumValue", `The ECProperty ${this._currentItemFullName}.${propName} has an invalid 'minimumValue' attribute. It should be a numeric value.`);
-        const maxValue = this.getOptionalIntAttribute(xmlElement, "maximumValue", `The ECProperty ${this._currentItemFullName}.${propName} has an invalid 'maximumValue' attribute. It should be a numeric value.`);
+        let minValue;
+        let maxValue;
+        if (primitiveType === _ECObjects__WEBPACK_IMPORTED_MODULE_1__.PrimitiveType.Double || primitiveType === _ECObjects__WEBPACK_IMPORTED_MODULE_1__.PrimitiveType.Long) {
+            minValue = this.getOptionalFloatAttribute(xmlElement, "minimumValue", `The ECProperty ${this._currentItemFullName}.${propName} has an invalid 'minimumValue' attribute. It should be a numeric value.`);
+            maxValue = this.getOptionalFloatAttribute(xmlElement, "maximumValue", `The ECProperty ${this._currentItemFullName}.${propName} has an invalid 'maximumValue' attribute. It should be a numeric value.`);
+        }
+        else {
+            minValue = this.getOptionalIntAttribute(xmlElement, "minimumValue", `The ECProperty ${this._currentItemFullName}.${propName} has an invalid 'minimumValue' attribute. It should be a numeric value.`);
+            maxValue = this.getOptionalIntAttribute(xmlElement, "maximumValue", `The ECProperty ${this._currentItemFullName}.${propName} has an invalid 'maximumValue' attribute. It should be a numeric value.`);
+        }
         return {
             ...propertyProps,
             extendedTypeName,
@@ -94264,6 +94301,2441 @@ class ECSchemaError extends _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.Ben
 }
 
 
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/ClassParsers.js":
+/*!*******************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/IncrementalLoading/ClassParsers.js ***!
+  \*******************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ClassParser: () => (/* binding */ ClassParser),
+/* harmony export */   CustomAttributeClassParser: () => (/* binding */ CustomAttributeClassParser),
+/* harmony export */   MixinParser: () => (/* binding */ MixinParser),
+/* harmony export */   RelationshipClassParser: () => (/* binding */ RelationshipClassParser)
+/* harmony export */ });
+/* harmony import */ var _ECObjects__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../ECObjects */ "../../core/ecschema-metadata/lib/esm/ECObjects.js");
+/* harmony import */ var _SchemaItemParsers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./SchemaItemParsers */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaItemParsers.js");
+/* harmony import */ var _SchemaParser__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./SchemaParser */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaParser.js");
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+
+
+/**
+ * Parses ClassProps JSON returned from an ECSql query and returns the correct ClassProps JSON.
+ * This is necessary as a small amount information (ie. CustomAttribute data) returned from the
+ * iModelDb is in a different format than is required for a ClassProps JSON object.
+ * @internal
+ */
+class ClassParser extends _SchemaItemParsers__WEBPACK_IMPORTED_MODULE_1__.SchemaItemParser {
+    /**
+     * Parses the given ClassProps JSON returned from an ECSql query.
+     * @param data The ClassProps JSON as returned from an iModelDb.
+     * @returns The corrected ClassProps Json.
+     */
+    async parse(data) {
+        const props = await super.parse(data);
+        if (props.properties) {
+            if (props.properties.length === 0)
+                delete props.properties;
+            else
+                this.parseProperties(props.properties);
+        }
+        return props;
+    }
+    parseProperties(propertyProps) {
+        for (const props of propertyProps) {
+            props.customAttributes = props.customAttributes && props.customAttributes.length > 0 ? props.customAttributes.map((attr) => { return (0,_SchemaParser__WEBPACK_IMPORTED_MODULE_2__.parseCustomAttribute)(attr); }) : undefined;
+            if (!props.customAttributes)
+                delete props.customAttributes;
+        }
+    }
+}
+/**
+ * Parses the given MixinProps JSON returned from an ECSql query.
+ * @param data The MixinProps JSON as returned from an iModelDb.
+ * @returns The corrected MixinProps Json.
+ * @internal
+ */
+class MixinParser extends ClassParser {
+    /**
+     * Parses the given MixinProps JSON returned from an ECSql query.
+     * @param data The MixinProps JSON as returned from an iModelDb.
+     * @returns The corrected MixinProps Json.
+     */
+    async parse(data) {
+        const props = await super.parse(data);
+        if (!props.customAttributes)
+            delete props.customAttributes;
+        return props;
+    }
+}
+/**
+ * Parses the given CustomAttributeClassProps JSON returned from an ECSql query.
+ * @param data The CustomAttributeClassProps JSON as returned from an iModelDb.
+ * @returns The corrected CustomAttributeClassProps Json.
+ * @internal
+ */
+class CustomAttributeClassParser extends ClassParser {
+    /**
+     * Parses the given CustomAttributeClassProps JSON returned from an ECSql query.
+     * @param data The CustomAttributeClassProps JSON as returned from an iModelDb.
+     * @returns The corrected CustomAttributeClassProps Json.
+     */
+    async parse(data) {
+        const props = await super.parse(data);
+        props.appliesTo = props.appliesTo ? (0,_ECObjects__WEBPACK_IMPORTED_MODULE_0__.containerTypeToString)(props.appliesTo) : _ECObjects__WEBPACK_IMPORTED_MODULE_0__.CustomAttributeContainerType[_ECObjects__WEBPACK_IMPORTED_MODULE_0__.CustomAttributeContainerType.Any];
+        return props;
+    }
+}
+/**
+ * Parses the given RelationshipClassProps JSON returned from an ECSql query.
+ * @param data The RelationshipClassProps JSON as returned from an iModelDb.
+ * @returns The corrected RelationshipClassProps Json.
+ * @internal
+ */
+class RelationshipClassParser extends ClassParser {
+    /**
+     * Parses the given RelationshipClassProps JSON returned from an ECSql query.
+     * @param data The RelationshipClassProps JSON as returned from an iModelDb.
+     * @returns The corrected RelationshipClassProps Json.
+     */
+    async parse(data) {
+        const props = await super.parse(data);
+        const source = props.source;
+        const target = props.target;
+        if (source) {
+            source.customAttributes = source.customAttributes ? source.customAttributes.map((attr) => { return (0,_SchemaParser__WEBPACK_IMPORTED_MODULE_2__.parseCustomAttribute)(attr); }) : undefined;
+            if (!source.customAttributes)
+                delete source.customAttributes;
+        }
+        if (target) {
+            target.customAttributes = target.customAttributes ? target.customAttributes.map((attr) => { return (0,_SchemaParser__WEBPACK_IMPORTED_MODULE_2__.parseCustomAttribute)(attr); }) : undefined;
+            if (!target.customAttributes)
+                delete target.customAttributes;
+        }
+        return props;
+    }
+}
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/ECSqlSchemaLocater.js":
+/*!*************************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/IncrementalLoading/ECSqlSchemaLocater.js ***!
+  \*************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ECSqlSchemaLocater: () => (/* binding */ ECSqlSchemaLocater)
+/* harmony export */ });
+/* harmony import */ var _ECObjects__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../ECObjects */ "../../core/ecschema-metadata/lib/esm/ECObjects.js");
+/* harmony import */ var _SchemaKey__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../SchemaKey */ "../../core/ecschema-metadata/lib/esm/SchemaKey.js");
+/* harmony import */ var _FullSchemaQueries__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./FullSchemaQueries */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/FullSchemaQueries.js");
+/* harmony import */ var _IncrementalSchemaLocater__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./IncrementalSchemaLocater */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/IncrementalSchemaLocater.js");
+/* harmony import */ var _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./SchemaItemQueries */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaItemQueries.js");
+/* harmony import */ var _SchemaParser__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./SchemaParser */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaParser.js");
+/* harmony import */ var _SchemaStubQueries__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./SchemaStubQueries */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaStubQueries.js");
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+/**
+ * An abstract [[IncrementalSchemaLocater]] implementation for loading
+ * EC [Schema] instances from an iModelDb using ECSql queries.
+ * @internal
+ */
+class ECSqlSchemaLocater extends _IncrementalSchemaLocater__WEBPACK_IMPORTED_MODULE_3__.IncrementalSchemaLocater {
+    /**
+     * Gets the [[ECSqlSchemaLocaterOptions]] used by this locater.
+     */
+    get options() {
+        return super.options;
+    }
+    /**
+     * Initializes a new ECSqlSchemaLocater instance.
+     * @param options The options used by this Schema locater.
+     */
+    constructor(options) {
+        super(options);
+    }
+    /**
+     * Gets the [[SchemaProps]] for the given schema key. This is the full schema json with all elements that are defined
+     * in the schema. The schema locater calls this after the stub has been loaded to fully load the schema in the background.
+     * @param schemaKey   The [[SchemaKey]] of the schema to be resolved.
+     * @param context     The [[SchemaContext]] to use for resolving references.
+     * @internal
+     */
+    async getSchemaJson(schemaKey, context) {
+        // If the meta schema is an earlier version than 4.0.3, we can't use the ECSql query interface to get the schema
+        // information required to load the schema entirely. In this case, we fallback to use the ECSchema RPC interface
+        // to fetch the whole schema json.
+        if (!await this.supportPartialSchemaLoading(context))
+            return this.getSchemaProps(schemaKey);
+        const start = Date.now();
+        const schemaProps = this.options.useMultipleQueries
+            ? await this.getFullSchemaMultipleQueries(schemaKey, context)
+            : await this.getFullSchema(schemaKey, context);
+        this.options.performanceLogger?.logSchema(start, schemaKey.name);
+        return schemaProps;
+    }
+    ;
+    /**
+     * Gets the [[SchemaProps]] without schemaItems.
+     */
+    /**
+     * Gets the [[SchemaProps]] without schemaItems for the given schema name.
+     * @param schemaName The name of the Schema.
+     * @param context The [[SchemaContext]] to use for resolving references.
+     * @returns
+     * @internal
+     */
+    async getSchemaNoItems(schemaName, context) {
+        const schemaRows = await this.executeQuery(_FullSchemaQueries__WEBPACK_IMPORTED_MODULE_2__.FullSchemaQueries.schemaNoItemsQuery, { parameters: { schemaName } });
+        const schemaRow = schemaRows[0];
+        if (schemaRow === undefined)
+            return undefined;
+        const schema = JSON.parse(schemaRow.schema);
+        return _SchemaParser__WEBPACK_IMPORTED_MODULE_5__.SchemaParser.parse(schema, context);
+    }
+    /**
+     * Checks if the [[SchemaContext]] has the right Meta Schema version to support the incremental schema loading.
+     * @param context   The schema context to lookup the meta schema.
+     * @returns         true if the context has a supported meta schema version, false otherwise.
+     */
+    async supportPartialSchemaLoading(context) {
+        const metaSchemaKey = new _SchemaKey__WEBPACK_IMPORTED_MODULE_1__.SchemaKey("ECDbMeta", 4, 0, 3);
+        const metaSchemaInfo = await context.getSchemaInfo(metaSchemaKey, _ECObjects__WEBPACK_IMPORTED_MODULE_0__.SchemaMatchType.LatestWriteCompatible);
+        return metaSchemaInfo !== undefined;
+    }
+    ;
+    /**
+     * Gets all the Schema's Entity classes as [[EntityClassProps]] JSON objects.
+     * @param schemaName The name of the Schema.
+     * @param context The [[SchemaContext]] to which the schema belongs.
+     * @returns A promise that resolves to a EntityClassProps array. Maybe empty of no entities are found.
+     * @internal
+     */
+    async getEntities(schema, context, queryOverride) {
+        const query = queryOverride ?? _FullSchemaQueries__WEBPACK_IMPORTED_MODULE_2__.FullSchemaQueries.entityQuery;
+        return this.querySchemaItem(context, schema, query, "EntityClass");
+    }
+    /**
+     * Gets all the Schema's Mixin classes as [[MixinProps]] JSON objects.
+     * @param schemaName The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a MixinProps array. Maybe empty of no entities are found.
+     * @internal
+     */
+    async getMixins(schema, context, queryOverride) {
+        const query = queryOverride ?? _FullSchemaQueries__WEBPACK_IMPORTED_MODULE_2__.FullSchemaQueries.mixinQuery;
+        return this.querySchemaItem(context, schema, query, "Mixin");
+    }
+    /**
+     * Gets all the Schema's Relationship classes as [[RelationshipClassProps]] JSON objects.
+     * @param schemaName The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a RelationshipClassProps array. Maybe empty if no items are found.
+     * @internal
+     */
+    async getRelationships(schema, context, queryOverride) {
+        const query = queryOverride ?? _FullSchemaQueries__WEBPACK_IMPORTED_MODULE_2__.FullSchemaQueries.relationshipClassQuery;
+        return this.querySchemaItem(context, schema, query, "RelationshipClass");
+    }
+    /**
+     * Gets all the Schema's CustomAttributeClass items as [[CustomAttributeClassProps]] JSON objects.
+     * @param schemaName The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a CustomAttributeClassProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getCustomAttributeClasses(schema, context, queryOverride) {
+        const query = queryOverride ?? _FullSchemaQueries__WEBPACK_IMPORTED_MODULE_2__.FullSchemaQueries.customAttributeQuery;
+        return this.querySchemaItem(context, schema, query, "CustomAttributeClass");
+    }
+    /**
+     * Gets all the Schema's StructClass items as [[StructClassProps]] JSON objects.
+     * @param schemaName The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a StructClassProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getStructs(schema, context, queryOverride) {
+        const query = queryOverride ?? _FullSchemaQueries__WEBPACK_IMPORTED_MODULE_2__.FullSchemaQueries.structQuery;
+        return this.querySchemaItem(context, schema, query, "StructClass");
+    }
+    /**
+     * Gets all the Schema's KindOfQuantity items as [[KindOfQuantityProps]] JSON objects.
+     * @param schema The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a KindOfQuantityProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getKindOfQuantities(schema, context) {
+        return this.querySchemaItem(context, schema, _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__.SchemaItemQueries.kindOfQuantity(true), "KindOfQuantity");
+    }
+    /**
+     * Gets all the Schema's PropertyCategory items as [[PropertyCategoryProps]] JSON objects.
+     * @param schema The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a PropertyCategoryProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getPropertyCategories(schema, context) {
+        return this.querySchemaItem(context, schema, _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__.SchemaItemQueries.propertyCategory(true), "PropertyCategory");
+    }
+    /**
+     * Gets all the Schema's Enumeration items as [[EnumerationProps]] JSON objects.
+     * @param schema The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a EnumerationProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getEnumerations(schema, context) {
+        return this.querySchemaItem(context, schema, _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__.SchemaItemQueries.enumeration(true), "Enumeration");
+    }
+    /**
+     * Gets all the Schema's Unit items as [[SchemaItemUnitProps]] JSON objects.
+     * @param schema The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a SchemaItemUnitProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getUnits(schema, context) {
+        return this.querySchemaItem(context, schema, _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__.SchemaItemQueries.unit(true), "Unit");
+    }
+    /**
+     * Gets all the Schema's InvertedUnit items as [[InvertedUnitProps]] JSON objects.
+     * @param schema The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a InvertedUnitProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getInvertedUnits(schema, context) {
+        return this.querySchemaItem(context, schema, _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__.SchemaItemQueries.invertedUnit(true), "InvertedUnit");
+    }
+    /**
+     * Gets all the Schema's Constant items as [[ConstantProps]] JSON objects.
+     * @param schema The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a ConstantProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getConstants(schema, context) {
+        return this.querySchemaItem(context, schema, _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__.SchemaItemQueries.constant(true), "Constant");
+    }
+    /**
+     * Gets all the Schema's UnitSystem items as [[UnitSystemProps]] JSON objects.
+     * @param schema The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a UnitSystemProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getUnitSystems(schema, context) {
+        return this.querySchemaItem(context, schema, _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__.SchemaItemQueries.unitSystem(true), "UnitSystem");
+    }
+    /**
+     * Gets all the Schema's Phenomenon items as [[PhenomenonProps]] JSON objects.
+     * @param schema The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a PhenomenonProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getPhenomenon(schema, context) {
+        return this.querySchemaItem(context, schema, _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__.SchemaItemQueries.phenomenon(true), "Phenomenon");
+    }
+    /**
+     * Gets all the Schema's Format items as [[SchemaItemFormatProps]] JSON objects.
+     * @param schema The name of the Schema.
+     * @param context The SchemaContext to which the schema belongs.
+     * @returns A promise that resolves to a SchemaItemFormatProps array. Maybe empty if not items are found.
+     * @internal
+     */
+    async getFormats(schema, context) {
+        return this.querySchemaItem(context, schema, _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_4__.SchemaItemQueries.format(true), "Format");
+    }
+    /**
+     * Gets [[SchemaInfo]] objects for all schemas including their direct schema references.
+     * @internal
+     */
+    async loadSchemaInfos() {
+        const schemaRows = await this.executeQuery(_SchemaStubQueries__WEBPACK_IMPORTED_MODULE_6__.ecsqlQueries.schemaInfoQuery);
+        return schemaRows.map((schemaRow) => ({
+            alias: schemaRow.alias,
+            schemaKey: _SchemaKey__WEBPACK_IMPORTED_MODULE_1__.SchemaKey.parseString(`${schemaRow.name}.${schemaRow.version}`),
+            references: Array.from(JSON.parse(schemaRow.references), parseSchemaReference),
+        }));
+    }
+    /**
+     * Gets the [[SchemaProps]] to create the basic schema skeleton. Depending on which options are set, the schema items or class hierarchy
+     * can be included in the initial fetch.
+     * @param schemaKey The [[SchemaKey]] of the schema to be resolved.
+     * @returns A promise that resolves to the schema partials, which is an array of [[SchemaProps]].
+     * @internal
+     */
+    async getSchemaPartials(schemaKey, context) {
+        const [schemaRow] = await this.executeQuery(_SchemaStubQueries__WEBPACK_IMPORTED_MODULE_6__.ecsqlQueries.schemaStubQuery, {
+            parameters: { schemaName: schemaKey.name },
+            limit: 1
+        });
+        if (!schemaRow)
+            return undefined;
+        const schemaPartials = [];
+        const addSchema = async (key) => {
+            const stub = await this.createSchemaProps(key, context);
+            schemaPartials.push(stub);
+            if (stub.references) {
+                for (const referenceProps of stub.references) {
+                    if (!schemaPartials.some((schema) => schema.name === referenceProps.name)) {
+                        await addSchema(_SchemaKey__WEBPACK_IMPORTED_MODULE_1__.SchemaKey.parseString(`${referenceProps.name}.${referenceProps.version}`));
+                    }
+                }
+            }
+            return stub;
+        };
+        const addItems = async (schemaName, itemInfo) => {
+            let schemaStub = schemaPartials.find((schema) => schema.name === schemaName);
+            if (!schemaStub) {
+                schemaStub = await addSchema(_SchemaKey__WEBPACK_IMPORTED_MODULE_1__.SchemaKey.parseString(`${schemaName}.0.0.0`));
+            }
+            if (!schemaStub.items) {
+                Object.assign(schemaStub, { items: {} });
+            }
+            const existingItem = schemaStub.items[itemInfo.name] || {};
+            Object.assign(schemaStub.items, { [itemInfo.name]: Object.assign(existingItem, itemInfo) });
+        };
+        const reviver = (_key, value) => {
+            if (value === null) {
+                return undefined;
+            }
+            return value;
+        };
+        await addSchema(schemaKey);
+        await parseSchemaItemStubs(schemaKey.name, context, JSON.parse(schemaRow.items, reviver), addItems);
+        return schemaPartials;
+    }
+    async querySchemaItem(context, schemaName, query, schemaType) {
+        const start = Date.now();
+        const itemRows = await this.executeQuery(query, { parameters: { schemaName } });
+        this.options.performanceLogger?.logSchemaItem(start, schemaName, schemaType, itemRows.length);
+        if (itemRows.length === 0)
+            return [];
+        const items = itemRows.map((itemRow) => {
+            return "string" === typeof itemRow.item ? JSON.parse(itemRow.item) : itemRow.item;
+        });
+        return await _SchemaParser__WEBPACK_IMPORTED_MODULE_5__.SchemaParser.parseSchemaItems(items, schemaName, context) ?? [];
+    }
+    async getFullSchema(schemaKey, context) {
+        const schemaRows = await this.executeQuery(_FullSchemaQueries__WEBPACK_IMPORTED_MODULE_2__.FullSchemaQueries.schemaQuery, { parameters: { schemaName: schemaKey.name } });
+        const schemaRow = schemaRows[0];
+        if (schemaRow === undefined)
+            return undefined;
+        // Map SchemaItemRow array, [{item: SchemaItemProps}], to array of SchemaItemProps.
+        const schema = JSON.parse(schemaRow.schema);
+        if (schema.items) {
+            schema.items = schema.items.map((itemRow) => { return itemRow.item; });
+        }
+        return _SchemaParser__WEBPACK_IMPORTED_MODULE_5__.SchemaParser.parse(schema, context);
+    }
+    async getFullSchemaMultipleQueries(schemaKey, context) {
+        const schema = await this.getSchemaNoItems(schemaKey.name, context);
+        if (!schema)
+            return undefined;
+        schema.items = {};
+        await Promise.all([
+            this.getEntities(schemaKey.name, context),
+            this.getMixins(schemaKey.name, context),
+            this.getStructs(schemaKey.name, context),
+            this.getRelationships(schemaKey.name, context),
+            this.getCustomAttributeClasses(schemaKey.name, context),
+            this.getKindOfQuantities(schemaKey.name, context),
+            this.getPropertyCategories(schemaKey.name, context),
+            this.getEnumerations(schemaKey.name, context),
+            this.getUnits(schemaKey.name, context),
+            this.getInvertedUnits(schemaKey.name, context),
+            this.getUnitSystems(schemaKey.name, context),
+            this.getConstants(schemaKey.name, context),
+            this.getPhenomenon(schemaKey.name, context),
+            this.getFormats(schemaKey.name, context)
+        ]).then((itemResults) => {
+            const flatItemList = itemResults.reduce((acc, item) => acc.concat(item));
+            flatItemList.forEach((schemaItem) => {
+                schema.items[schemaItem.name] = schemaItem;
+            });
+        });
+        return schema;
+    }
+}
+function parseSchemaReference(referenceName) {
+    return { schemaKey: _SchemaKey__WEBPACK_IMPORTED_MODULE_1__.SchemaKey.parseString(referenceName) };
+}
+async function parseSchemaItemStubs(schemaName, context, itemRows, addItemsHandler) {
+    if (!itemRows || itemRows.length === 0) {
+        return;
+    }
+    const parseBaseClasses = async (baseClasses) => {
+        if (!baseClasses || baseClasses.length < 2)
+            return;
+        for (let index = baseClasses.length - 1; index >= 0;) {
+            const currentItem = baseClasses[index--];
+            const baseClassItem = baseClasses[index];
+            const baseClassName = baseClassItem ? `${baseClassItem.schema}.${baseClassItem.name}` : undefined;
+            const schemaItem = await _SchemaParser__WEBPACK_IMPORTED_MODULE_5__.SchemaParser.parseItem(currentItem, currentItem.schema, context);
+            await addItemsHandler(currentItem.schema, {
+                ...schemaItem,
+                name: schemaItem.name,
+                schemaItemType: (0,_ECObjects__WEBPACK_IMPORTED_MODULE_0__.parseSchemaItemType)(schemaItem.schemaItemType),
+                baseClass: baseClassName,
+            });
+        }
+    };
+    for (const itemRow of itemRows) {
+        const schemaItem = await _SchemaParser__WEBPACK_IMPORTED_MODULE_5__.SchemaParser.parseItem(itemRow, schemaName, context);
+        await addItemsHandler(schemaName, {
+            ...schemaItem,
+            name: schemaItem.name,
+            schemaItemType: (0,_ECObjects__WEBPACK_IMPORTED_MODULE_0__.parseSchemaItemType)(schemaItem.schemaItemType),
+            mixins: itemRow.mixins
+                ? itemRow.mixins.map(mixin => { return `${mixin.schema}.${mixin.name}`; })
+                : undefined,
+        });
+        await parseBaseClasses(itemRow.baseClasses);
+        for (const mixinRow of itemRow.mixins || []) {
+            const mixinItem = await _SchemaParser__WEBPACK_IMPORTED_MODULE_5__.SchemaParser.parseItem(mixinRow, mixinRow.schema, context);
+            await addItemsHandler(mixinRow.schema, {
+                ...mixinItem,
+                name: mixinItem.name,
+                schemaItemType: (0,_ECObjects__WEBPACK_IMPORTED_MODULE_0__.parseSchemaItemType)(mixinItem.schemaItemType),
+            });
+            await parseBaseClasses(mixinRow.baseClasses);
+        }
+    }
+}
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/FullSchemaQueries.js":
+/*!************************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/IncrementalLoading/FullSchemaQueries.js ***!
+  \************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   FullSchemaQueries: () => (/* binding */ FullSchemaQueries)
+/* harmony export */ });
+/* harmony import */ var _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./SchemaItemQueries */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaItemQueries.js");
+/* harmony import */ var _SchemaStubQueries__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./SchemaStubQueries */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaStubQueries.js");
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+
+/**
+ * Queries that return full Schema JSON data are found here. Shared SELECTS and
+ * WITH clauses are broken down into individual variables.
+ */
+const propertyType = (alias) => {
+    return `
+    CASE
+      WHEN [${alias}].[Kind] = 0 THEN 'PrimitiveProperty'
+      WHEN [${alias}].[Kind] = 1 THEN 'StructProperty'
+      WHEN [${alias}].[Kind] = 2 THEN 'PrimitiveArrayProperty'
+      WHEN [${alias}].[Kind] = 3 THEN 'StructArrayProperty'
+      WHEN [${alias}].[Kind] = 4 THEN 'NavigationProperty'
+      ELSE NULL
+    END
+  `;
+};
+const navigationDirection = (alias) => {
+    return `
+    CASE
+      WHEN [${alias}].[NavigationDirection] = 1 THEN 'Forward'
+      WHEN [${alias}].[NavigationDirection] = 2 THEN 'Backward'
+      ELSE NULL
+    END
+  `;
+};
+const schemaCustomAttribute = (alias) => {
+    return `
+    SELECT
+      json_group_array(json(XmlCAToJson([ca].[Class].[Id], [ca].[Instance])))
+      FROM [meta].[CustomAttribute] [ca]
+    WHERE [ca].[ContainerId] = [${alias}].[ECInstanceId] AND [ca].[ContainerType] = 1
+    ORDER BY [ca].[Ordinal]
+  `;
+};
+/**
+ * Selects customAttribute data for each class type.
+ */
+const classCustomAttribute = (alias) => {
+    return `
+    SELECT
+      json_group_array(json(XmlCAToJson([ca].[Class].[Id], [ca].[Instance])))
+    FROM [meta].[CustomAttribute] [ca]
+    WHERE [ca].[ContainerId] = [${alias}].[ECInstanceId] AND [ca].[ContainerType] = 30
+    ORDER BY [ca].[Ordinal]
+  `;
+};
+const propertyCustomAttribute = (alias) => {
+    return `
+    SELECT
+      json_group_array(json(XmlCAToJson([ca].[Class].[Id], [ca].[Instance])))
+    FROM [meta].[CustomAttribute] [ca]
+    WHERE [ca].[ContainerId] = [${alias}].[ECInstanceId] AND [ca].[ContainerType] = 992
+    ORDER BY [ca].[Ordinal]
+  `;
+};
+/**
+ * Selects base class data for each class type.
+ */
+const selectBaseClasses = `
+  SELECT
+    ec_classname([baseClass].[ECInstanceId], 's.c')
+  FROM
+    [meta].[ECClassDef] [baseClass]
+  INNER JOIN [meta].[ClassHasBaseClasses] [baseClassMap]
+    ON [baseClassMap].[TargetECInstanceId] = [baseClass].[ECInstanceId]
+  WHERE [baseClassMap].[SourceECInstanceId] = [class].[ECInstanceId]
+  LIMIT 1
+`;
+/**
+ * Selects class property data for each class type. ClassProperties
+ * is a common table expression (CTE or WITH clause) defined below.
+ */
+const selectProperties = `
+  SELECT
+    json_group_array(json([classProperties].[property]))
+  FROM
+    [ClassProperties] [classProperties]
+  WHERE
+    [classProperties].[ClassId] = [class].[ECInstanceId]
+`;
+/**
+ * A CTE used to select AppliesTo from IsMixin CustomAttributes for a given Mixin.
+ */
+const withAppliesTo = `
+  AppliesToCTE AS (
+    SELECT
+      [mixinAppliesTo].[ECInstanceId] AS [AppliesToId],
+      [appliesToSchema].[name] as [AppliesToSchema],
+      json_extract(XmlCAToJson([ca].[Class].[Id], [ca].[Instance]), '$.IsMixin.AppliesToEntityClass') AS [AppliesTo]
+    FROM [meta].[CustomAttribute] [ca]
+    JOIN [meta].[ECClassDef] [mixinAppliesTo]
+      ON [mixinAppliesTo].[ECInstanceId] = [ca].[ContainerId]
+    JOIN [meta].[ECSchemaDef] [appliesToSchema]
+      ON [appliesToSchema].[ECInstanceId] = [mixinAppliesTo].[Schema].[Id]
+    WHERE [ca].[ContainerType] = 30
+      AND json_extract(XmlCAToJson([ca].[Class].[Id], [ca].[Instance]), '$.ecClass') = 'IsMixin'
+  )
+`;
+/**
+ * A CTE used to select Schema reference data for a given Schema.
+ */
+const withSchemaReferences = `
+SchemaReferences as (
+  SELECT
+    [ref].[SourceECInstanceId] as [SchemaId],
+    json_object(
+      'name', [Name],
+      'version', CONCAT(printf('%02d', [VersionMajor]), '.', printf('%02d', [VersionWrite]), '.', printf('%02d', [VersionMinor]))
+    ) as [reference]
+  FROM
+    [meta].[ECSchemaDef] as [refSchema]
+  INNER JOIN [meta].[SchemaHasSchemaReferences] [ref]
+    ON [ref].[TargetECInstanceId] = [refSchema].[ECInstanceId]
+)
+`;
+/**
+ * A CTE used to select Relationship constraints for a given RelationshipClass.
+ */
+const withRelationshipConstraints = `
+ClassRelationshipConstraints as (
+  SELECT
+    [rhc].[SourceECInstanceId] as [ClassId],
+    [constraintDef].[ECInstanceId] as [ConstraintId],
+    [RelationshipEnd],
+    CONCAT('(', [MultiplicityLowerLimit], '..', IIF([MultiplicityUpperLimit] IS NULL, '*', [MultiplicityUpperLimit]), ')') as [Multiplicity],
+    [IsPolyMorphic],
+    [RoleLabel],
+    IIF([constraintDef].[AbstractConstraintClass] IS NOT NULL, ec_classname([constraintDef].[AbstractConstraintClass].[Id], 's.c'), null) as [AbstractConstraint],
+    IIF ([rchc].[TargetECInstanceId] IS NOT NULL, JSON_GROUP_ARRAY(ec_classname([rchc].[TargetECInstanceId], 's.c')), null) as [ConstraintClasses]
+  FROM
+    [meta].[ECRelationshipConstraintDef] [constraintDef]
+  JOIN [meta].[RelationshipHasConstraints] [rhc]
+    ON [rhc].[TargetECInstanceId] = [constraintDef].[ECInstanceId]
+  JOIN [meta].[RelationshipConstraintHasClasses] [rchc]
+    ON [rchc].[SourceECInstanceId] = [constraintDef].[ECInstanceId]
+  GROUP BY [constraintDef].[ECInstanceId]
+)
+`;
+/**
+ * A CTE used to select Class property data for a given Class.
+ */
+const withClassProperties = `
+ClassProperties as (
+SELECT
+  [cop].[SourceECInstanceId] as [ClassId],
+  json_object(
+    'name', [pd].[Name],
+    'label', [pd].[DisplayLabel],
+    'description', [pd].[Description],
+    'isReadOnly', IIF([pd].[IsReadOnly] = 1, json('true'), NULL),
+    'priority', [pd].[Priority],
+    'category', IIF([categoryDef].[Name] IS NULL, NULL, CONCAT([categorySchemaDef].[Name], '.', [categoryDef].[Name])),
+    'kindOfQuantity', IIF([koqDef].[Name] IS NULL, NULL, CONCAT([koqSchemaDef].[Name], '.', [koqDef].[Name])),
+    'typeName',
+      CASE
+        WHEN [pd].[Kind] = 0 OR [pd].[Kind] = 2 Then
+          CASE
+            WHEN [enumDef].[Name] IS NOT NULL Then CONCAT([enumSchemaDef].[Name], '.', [enumDef].[Name])
+            WHEN [pd].[PrimitiveType] = 257 Then 'binary'
+            WHEN [pd].[PrimitiveType] = 513 Then 'boolean'
+            WHEN [pd].[PrimitiveType] = 769 Then 'dateTime'
+            WHEN [pd].[PrimitiveType] = 1025 Then 'double'
+            WHEN [pd].[PrimitiveType] = 1281 Then 'int'
+            WHEN [pd].[PrimitiveType] = 1537 Then 'long'
+            WHEN [pd].[PrimitiveType] = 1793 Then 'point2d'
+            WHEN [pd].[PrimitiveType] = 2049 Then 'point3d'
+            WHEN [pd].[PrimitiveType] = 2305 Then 'string'
+            WHEN [pd].[PrimitiveType] = 2561 Then 'Bentley.Geometry.Common.IGeometry'
+            ELSE null
+          END
+        WHEN [pd].[Kind] = 1 OR [pd].[Kind] = 3 Then
+          CONCAT([structSchemaDef].[Name], '.', [structDef].[Name])
+        ELSE null
+      END,
+    'type', ${propertyType("pd")},
+    'minLength', [pd].[PrimitiveTypeMinLength],
+    'maxLength', [pd].[PrimitiveTypeMaxLength],
+    'minValue', [pd].[PrimitiveTypeMinValue],
+    'maxValue', [pd].[PrimitiveTypeMaxValue],
+    'extendedTypeName', [pd].[ExtendedTypeName],
+    'minOccurs', [pd].[ArrayMinOccurs],
+    'maxOccurs', [pd].[ArrayMaxOccurs],
+    'direction', ${navigationDirection("pd")},
+    'relationshipName', IIF([navRelDef].[Name] IS NULL, NULL, CONCAT([navSchemaDef].[Name], '.', [navRelDef].[Name])),
+    'customAttributes', (${propertyCustomAttribute("pd")})
+  ) as [property]
+FROM
+  [meta].[ECPropertyDef] as [pd]
+JOIN [meta].[ClassOwnsLocalProperties] [cop]
+  ON cop.[TargetECInstanceId] = [pd].[ECInstanceId]
+LEFT JOIN [meta].[ECEnumerationDef] [enumDef]
+  ON [enumDef].[ECInstanceId] = [pd].[Enumeration].[Id]
+LEFT JOIN [meta].[ECSchemaDef] enumSchemaDef
+  ON [enumSchemaDef].[ECInstanceId] = [enumDef].[Schema].[Id]
+LEFT JOIN [meta].[PropertyCategoryDef] [categoryDef]
+  ON [categoryDef].[ECInstanceId] = [pd].[Category].[Id]
+LEFT JOIN [meta].[ECSchemaDef] [categorySchemaDef]
+  ON [categorySchemaDef].[ECInstanceId] = [categoryDef].[Schema].[Id]
+LEFT JOIN [meta].[KindOfQuantityDef] [koqDef]
+  ON [koqDef].[ECInstanceId] = [pd].[KindOfQuantity].[Id]
+LEFT JOIN [meta].[ECSchemaDef] [koqSchemaDef]
+  ON [koqSchemaDef].[ECInstanceId] = [koqDef].[Schema].[Id]
+LEFT JOIN [meta].[ECClassDef] [structDef]
+  ON structDef.[ECInstanceId] = [pd].[StructClass].[Id]
+LEFT JOIN [meta].[ECSchemaDef] [structSchemaDef]
+  ON [structSchemaDef].[ECInstanceId] = [structDef].[Schema].[Id]
+LEFT JOIN [meta].[ECClassDef] [navRelDef]
+  ON [navRelDef].[ECInstanceId] = [pd].[NavigationRelationshipClass].[Id]
+LEFT JOIN [meta].[ECSchemaDef] [navSchemaDef]
+  ON [navSchemaDef].[ECInstanceId] = [navRelDef].[Schema].[Id]
+)
+`;
+/**
+ * Query that provides EntityClass data and is shared by two cases:
+ * 1. A single query to return a full schema.
+ * 2. When querying a full schema with multiple schema item queries or
+ *    when just querying for Entity classes.
+ */
+const baseEntityQuery = `
+  SELECT
+    [sd].[Name] as [schema],
+    json_object (
+      'schemaItemType', 'EntityClass',
+      'name', [class].[Name],
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'modifier', ${(0,_SchemaStubQueries__WEBPACK_IMPORTED_MODULE_1__.modifier)("class")},
+      'baseClass', (
+        ${selectBaseClasses}
+      ),
+      'mixins', (
+        SELECT
+          json_group_array(
+            ec_classname([baseClass].[ECInstanceId], 's.c')
+          )
+        FROM
+          [meta].[ECClassDef] [baseClass]
+        INNER JOIN [meta].[ClassHasBaseClasses] [baseClassMap]
+          ON [baseClassMap].[TargetECInstanceId] = [baseClass].[ECInstanceId]
+        WHERE [baseClassMap].[SourceECInstanceId] = [class].[ECInstanceId]
+          AND EXISTS(SELECT 1 FROM [meta].[ClassCustomAttribute] [ca] WHERE [baseClass].[ECInstanceId] = [ca].[Class].[Id]
+          AND [ca].[CustomAttributeClass].[Id] Is ([CoreCA].[IsMixin]))
+      ),
+      'customAttributes', (${classCustomAttribute("class")}),
+      'properties', (
+        ${selectProperties}
+      )
+    ) AS [item]
+  FROM [meta].[ECClassDef] [class]
+  JOIN
+    [meta].[ECSchemaDef] [sd] ON [sd].[ECInstanceId] = [class].[Schema].[Id]
+  WHERE [class].[Type] = 0 AND
+    [sd].[Name] = :schemaName
+    AND NOT EXISTS(SELECT 1 FROM [meta].[ClassCustomAttribute] [ca] WHERE [class].[ECInstanceId] = [ca].[Class].[Id]
+    AND [ca].[CustomAttributeClass].Id Is ([CoreCA].[IsMixin]))
+ `;
+/**
+ * EntityClass query used to when querying for EntityClass data only. Not used
+ * for full Schema load via single query.
+ */
+const entityQuery = `
+  WITH
+    ${withClassProperties}
+  ${baseEntityQuery}
+ `;
+/**
+ * Query that provides Mixin data and is shared by two cases:
+ * 1. A single query to return a full schema.
+ * 2. When querying a full schema with multiple schema item queries or
+ *    when just querying for Mixin classes.
+ */
+const baseMixinQuery = `
+  SELECT
+    [sd].[Name] as [schema],
+    json_object (
+      'schemaItemType', 'Mixin',
+      'name', [class].[Name],
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'modifier', ${(0,_SchemaStubQueries__WEBPACK_IMPORTED_MODULE_1__.modifier)("class")},
+      'baseClass', (
+        ${selectBaseClasses}
+      ),
+      'appliesTo', (
+        SELECT IIF(instr([atCTE].[AppliesTo], ':') > 1, ec_classname(ec_classId([atCTE].[AppliesTo]), 's.c'), CONCAT([atCTE].[AppliesToSchema], '.', [atCTE].[AppliesTo]))
+        FROM [AppliesToCTE] [atCTE]
+        WHERE [atCTE].[AppliesToId] = [class].[ECInstanceId]
+      ),
+      'customAttributes', (
+        SELECT
+          json_group_array(json(XmlCAToJson([ca].[Class].[Id], [ca].[Instance])))
+        FROM [meta].[CustomAttribute] [ca]
+        WHERE [ca].[ContainerId] = [class].[ECInstanceId] AND [ca].[ContainerType] = 30
+          AND json_extract(XmlCAToJson([ca].[Class].[Id], [ca].[Instance]), '$.ecClass') <> 'IsMixin'
+      ),
+      'properties', (
+        SELECT
+          json_group_array(json([classProperties].[property]))
+        FROM
+          [ClassProperties] [classProperties]
+        WHERE
+          [classProperties].[ClassId] = [class].[ECInstanceId]
+      )
+    ) AS [item]
+  FROM [meta].[ECClassDef] [class]
+  JOIN
+    [meta].[ECSchemaDef] [sd] ON [sd].[ECInstanceId] = [class].[Schema].[Id]
+  WHERE [class].[Type] = 0 AND
+    [sd].[Name] = :schemaName
+    AND EXISTS(SELECT 1 FROM [meta].[ClassCustomAttribute] [ca] WHERE [class].[ECInstanceId] = [ca].[Class].[Id]
+    AND [ca].[CustomAttributeClass].[Id] Is ([CoreCA].[IsMixin]))
+ `;
+/**
+* Mixin query used to when querying for Mixin data only. Not used
+* for full Schema load via single query.
+*/
+const mixinQuery = `
+ WITH
+  ${withAppliesTo},
+  ${withClassProperties}
+${baseMixinQuery}
+`;
+/**
+ * Query that provides RelationshipClass data and is shared by two cases:
+ * 1. A single query to return a full schema.
+ * 2. When querying a full schema with multiple schema item queries or
+ *    when just querying for Relationship classes.
+ */
+const baseRelationshipClassQuery = `
+  SELECT
+    [sd].Name as schema,
+    json_object (
+      'schemaItemType', 'RelationshipClass',
+      'name', [class].[Name],
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'strength', ${(0,_SchemaStubQueries__WEBPACK_IMPORTED_MODULE_1__.strength)("class")},
+      'strengthDirection', ${(0,_SchemaStubQueries__WEBPACK_IMPORTED_MODULE_1__.strengthDirection)("class")},
+      'modifier', ${(0,_SchemaStubQueries__WEBPACK_IMPORTED_MODULE_1__.modifier)("class")},
+      'baseClass', (
+        ${selectBaseClasses}
+      ),
+      'customAttributes', (${classCustomAttribute("class")}),
+      'properties', (
+        ${selectProperties}
+      ),
+      'source', (
+        SELECT
+          json_object (
+            'multiplicity', [sourceConst].[Multiplicity],
+            'roleLabel', [sourceConst].[RoleLabel],
+            'polymorphic', IIF([sourceConst].[IsPolyMorphic] = 1, json('true'), json('false')),
+            'abstractConstraint', [sourceConst].[AbstractConstraint],
+            'constraintClasses', json([sourceConst].[ConstraintClasses]),
+            'customAttributes', (
+              SELECT
+                json_group_array(json(XmlCAToJson([ca].[Class].[Id], [ca].[Instance])))
+              FROM [meta].[CustomAttribute] [ca]
+              WHERE [ca].[ContainerId] = [sourceConst].[ConstraintId] AND [ca].[ContainerType] = 1024
+              ORDER BY [ca].[Ordinal]
+            )
+          )
+        FROM
+          [ClassRelationshipConstraints] [sourceConst]
+        WHERE [sourceConst].[relationshipEnd] = 0
+          AND [sourceConst].[ClassId] = [class].[ECInstanceId]
+      ),
+      'target', (
+        SELECT
+          json_object (
+            'multiplicity', [targetConst].[Multiplicity],
+            'roleLabel', [targetConst].[RoleLabel],
+            'polymorphic', IIF([targetConst].[IsPolyMorphic] = 1, json('true'), json('false')),
+            'abstractConstraint', [targetConst].[AbstractConstraint],
+            'constraintClasses', json([targetConst].[ConstraintClasses]),
+            'customAttributes', (
+              SELECT
+                json_group_array(json(XmlCAToJson([ca].[Class].[Id], [ca].[Instance])))
+              FROM [meta].[CustomAttribute] [ca]
+              WHERE [ca].[ContainerId] = [targetConst].[ConstraintId] AND [ca].[ContainerType] = 2048
+              ORDER BY [ca].[Ordinal]
+            )
+          )
+        FROM
+            [ClassRelationshipConstraints] [targetConst]
+        WHERE [targetConst].[relationshipEnd] = 1
+            AND [targetConst].[ClassId] = [class].[ECInstanceId]
+      )
+    ) AS [item]
+  FROM [meta].[ECClassDef] [class]
+  JOIN
+    [meta].[ECSchemaDef] [sd] ON [sd].[ECInstanceId] = [class].[Schema].[Id]
+  WHERE [class].[Type] = 1 AND
+    [sd].[Name] = :schemaName
+ `;
+/**
+* RelationshipClass query used to when querying for RelationshipClass data only. Not used
+* for full Schema load via single query.
+*/
+const relationshipClassQuery = `
+ WITH
+  ${withClassProperties},
+  ${withRelationshipConstraints}
+${baseRelationshipClassQuery}
+`;
+/**
+ * Query that provides StructClass data and is shared by two cases:
+ * 1. A single query to return a full schema.
+ * 2. When querying a full schema with multiple schema item queries or
+ *    when just querying for Struct classes.
+ */
+const baseStructQuery = `
+  SELECT
+    [sd].Name as schema,
+    json_object (
+      'schemaItemType', 'StructClass',
+      'name', [class].[Name],
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'modifier', ${(0,_SchemaStubQueries__WEBPACK_IMPORTED_MODULE_1__.modifier)("class")},
+      'baseClass', (
+        ${selectBaseClasses}
+      ),
+      'customAttributes', (${classCustomAttribute("class")}),
+      'properties', (
+        ${selectProperties}
+      )
+    ) AS item
+  FROM [meta].[ECClassDef] [class]
+  JOIN
+    [meta].[ECSchemaDef] [sd] ON [sd].[ECInstanceId] = [class].[Schema].[Id]
+  WHERE [class].[Type] = 2 AND
+    [sd].[Name] = :schemaName
+ `;
+/**
+ * StructClass query used to when querying for StructClass data only. Not used
+ * for full Schema load via single query.
+ */
+const structQuery = `
+ WITH
+  ${withClassProperties}
+${baseStructQuery}
+`;
+/**
+ * Query that provides CustomAttributeClass data and is shared by two cases:
+ * 1. A single query to return a full schema.
+ * 2. When querying a full schema with multiple schema item queries or
+ *    when just querying for CustomAttribute classes.
+ */
+const baseCustomAttributeQuery = `
+  SELECT
+    [sd].Name as schema,
+    json_object (
+      'schemaItemType', 'CustomAttributeClass',
+      'name', [class].[Name],
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'appliesTo', [class].[CustomAttributeContainerType],
+      'modifier', ${(0,_SchemaStubQueries__WEBPACK_IMPORTED_MODULE_1__.modifier)("class")},
+      'baseClass', (
+        ${selectBaseClasses}
+      ),
+      'customAttributes', (${classCustomAttribute("class")}),
+      'properties', (
+        ${selectProperties}
+      )
+    ) AS [item]
+  FROM [meta].[ECClassDef] [class]
+  JOIN
+    [meta].[ECSchemaDef] sd ON [sd].[ECInstanceId] = [class].[Schema].[Id]
+  WHERE [class].[Type] = 3 AND
+    [sd].[Name] = :schemaName
+ `;
+/**
+ * CustomAttributeClass query used to when querying for CustomAttributeClass data only. Not used
+ * for full Schema load via single query.
+ */
+const customAttributeQuery = `
+WITH
+  ${withClassProperties}
+${baseCustomAttributeQuery}
+`;
+/**
+ * Used by full schema load query via single query. Allows
+ * all SchemaItemTypes to be queried at once.
+ */
+const withSchemaItems = `
+SchemaItems AS (
+  ${baseEntityQuery}
+  UNION ALL
+  ${baseRelationshipClassQuery}
+  UNION ALL
+  ${baseStructQuery}
+  UNION ALL
+  ${baseMixinQuery}
+  UNION ALL
+  ${baseCustomAttributeQuery}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.kindOfQuantity(true)}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.enumeration(true)}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.propertyCategory(true)}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.unit(true)}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.invertedUnit(true)}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.unitSystem(true)}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.constant(true)}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.phenomenon(true)}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.format(true)}
+)
+`;
+/**
+ * Query for Schema data without SchemaItems
+ */
+const schemaNoItemsQuery = `
+WITH
+  ${withSchemaReferences}
+SELECT
+  json_object (
+    'name', [schemaDef].[Name],
+    'version', CONCAT(printf('%02d', [VersionMajor]), '.', printf('%02d', [VersionWrite]), '.', printf('%02d', [VersionMinor])),
+    'alias', [schemaDef].[Alias],
+    'label', [schemaDef].[DisplayLabel],
+    'description', [schemaDef].[Description],
+    'ecSpecMajorVersion', [schemaDef].[OriginalECXmlVersionMajor],
+    'ecSpecMinorVersion', [schemaDef].[OriginalECXmlVersionMinor],
+    'customAttributes', (${schemaCustomAttribute("schemaDef")}),
+    'references', (
+      SELECT
+        json_group_array(json([schemaReferences].[reference]))
+      FROM
+        [SchemaReferences] [schemaReferences]
+      WHERE
+        [schemaReferences].[SchemaId] = [schemaDef].[ECInstanceId]
+    )
+  ) as [schema]
+FROM
+  [meta].[ECSchemaDef] [schemaDef] WHERE [Name] = :schemaName
+`;
+/**
+ * Query to load a full Schema via a single query.
+ */
+const schemaQuery = `
+WITH
+  ${withAppliesTo},
+  ${withSchemaReferences},
+  ${withClassProperties},
+  ${withRelationshipConstraints},
+  ${withSchemaItems}
+SELECT
+  json_object (
+    'name', [schemaDef].[Name],
+    'version', CONCAT(printf('%02d', [VersionMajor]), '.', printf('%02d', [VersionWrite]), '.', printf('%02d', [VersionMinor])),
+    'alias', [schemaDef].[Alias],
+    'label', [schemaDef].[DisplayLabel],
+    'description', [schemaDef].[Description],
+    'ecSpecMajorVersion', [schemaDef].[OriginalECXmlVersionMajor],
+    'ecSpecMinorVersion', [schemaDef].[OriginalECXmlVersionMinor],
+    'customAttributes', (${schemaCustomAttribute("schemaDef")}),
+    'references', (
+      SELECT
+        json_group_array(json([schemaReferences].[reference]))
+      FROM
+        [SchemaReferences] [schemaReferences]
+      WHERE
+        [schemaReferences].[SchemaId] = [schemaDef].[ECInstanceId]
+    ),
+    'items', (
+      SELECT
+        json_group_array(json(json_object(
+          'item', json([items].[item])
+        )))
+      FROM
+        [SchemaItems] [items]
+    )
+) as [schema]
+FROM
+  [meta].[ECSchemaDef] [schemaDef] WHERE [Name] = :schemaName
+`;
+/**
+ * Queries for loading full Schema JSON.
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const FullSchemaQueries = {
+    schemaQuery,
+    schemaNoItemsQuery,
+    entityQuery,
+    relationshipClassQuery,
+    mixinQuery,
+    structQuery,
+    customAttributeQuery
+};
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/IncrementalSchemaLocater.js":
+/*!*******************************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/IncrementalLoading/IncrementalSchemaLocater.js ***!
+  \*******************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   IncrementalSchemaLocater: () => (/* binding */ IncrementalSchemaLocater)
+/* harmony export */ });
+/* harmony import */ var _Constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../Constants */ "../../core/ecschema-metadata/lib/esm/Constants.js");
+/* harmony import */ var _Deserialization_SchemaGraphUtil__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../Deserialization/SchemaGraphUtil */ "../../core/ecschema-metadata/lib/esm/Deserialization/SchemaGraphUtil.js");
+/* harmony import */ var _ECObjects__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../ECObjects */ "../../core/ecschema-metadata/lib/esm/ECObjects.js");
+/* harmony import */ var _Exception__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../Exception */ "../../core/ecschema-metadata/lib/esm/Exception.js");
+/* harmony import */ var _Metadata_Schema__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../Metadata/Schema */ "../../core/ecschema-metadata/lib/esm/Metadata/Schema.js");
+/* harmony import */ var _SchemaKey__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../SchemaKey */ "../../core/ecschema-metadata/lib/esm/SchemaKey.js");
+/* harmony import */ var _utils_SchemaLoadingController__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../utils/SchemaLoadingController */ "../../core/ecschema-metadata/lib/esm/utils/SchemaLoadingController.js");
+/* harmony import */ var _IncrementalSchemaReader__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./IncrementalSchemaReader */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/IncrementalSchemaReader.js");
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+
+/**
+ * A [[ISchemaLocater]] implementation for locating and retrieving EC [[Schema]]
+ * objects incrementally instead of the full schema and it's references at once. This is useful for large schemas that
+ * take a long time to load, but clients need a rough skeleton of the schema as fast as possible.
+ *
+ * The IncrementalSchemaLocater is a locater around the [[IncrementalSchemaLocater]] to be used in a
+ * [[SchemaContext]].
+ * @internal
+ */
+class IncrementalSchemaLocater {
+    _options;
+    _schemaInfoCache;
+    /**
+     * Initializes a new instance of the IncrementalSchemaLocater class.
+     * @param options  The [[SchemaLocaterOptions]] that control the loading of the schema.
+     */
+    constructor(options) {
+        this._options = options || {};
+        this._schemaInfoCache = new SchemaInfoCache(async (context) => {
+            return this.loadSchemaInfos(context);
+        });
+    }
+    /** Gets the options how the schema locater load the schemas. */
+    get options() {
+        return this._options;
+    }
+    /**
+     * Gets the [[SchemaInfo]] which matches the provided SchemaKey.  The SchemaInfo may be returned
+     * before the schema is fully loaded. May return the entire Schema so long as it is completely loaded as it satisfies
+     * the SchemaInfo interface.
+     * @param schemaKey   The [[SchemaKey]] to look up.
+     * @param matchType   The [[SchemaMatchType]] to use against candidate schemas.
+     * @param context     The [[SchemaContext]] for loading schema references.
+     */
+    async getSchemaInfo(schemaKey, matchType, context) {
+        return this._schemaInfoCache.lookup(schemaKey, matchType, context);
+    }
+    /**
+     * Attempts to get a [[Schema]] from the locater. Yields undefined if no matching schema is found.
+     * For schemas that may have references, construct and call through a SchemaContext instead.
+     * @param schemaKey   The [[SchemaKey]] to look up.
+     * @param matchType   The [[SchemaMatchType]] to use against candidate schemas.
+     * @param context     The [[SchemaContext]] for loading schema references.
+     */
+    async getSchema(schemaKey, matchType, context) {
+        const schemaInfo = await this.getSchemaInfo(schemaKey, matchType, context);
+        return schemaInfo
+            ? this.loadSchema(schemaInfo, context)
+            : undefined;
+    }
+    /**
+     * Attempts to get a [[Schema]] from the locater. Yields undefined if no matching schema is found.
+     * For schemas that may have references, construct and call through a SchemaContext instead.
+     * NOT IMPLEMENTED IN THIS LOCATER - ALWAYS RETURNS UNDEFINED.
+     * @param schemaKey   The [[SchemaKey]] to look up.
+     * @param matchType   The [[SchemaMatchType]] to use against candidate schemas.
+     * @param context     The [[SchemaContext]] for loading schema references.
+     * @returns           Incremental schema loading does not work synchronously, this will always return undefined.
+     */
+    getSchemaSync(_schemaKey, _matchType, _context) {
+        return undefined;
+    }
+    /**
+     * Start loading the schema for the given schema info incrementally. The schema is returned
+     * as soon as the schema stub is loaded while the schema fully resolves in the background. It should
+     * only be called by the IncrementalSchemaLocater if a schema has not been loaded or started to
+     * load yet.
+     * @param schemaInfo    The schema info of the schema to load.
+     * @param schemaContext The schema context to load the schema into.
+     */
+    async loadSchema(schemaInfo, schemaContext) {
+        // If the meta schema is an earlier version than 4.0.3, we can't use the ECSql query interface to get the schema
+        // information required to load the schema entirely. In this case, we fallback to use the ECSchema RPC interface
+        // to fetch the whole schema json.
+        if (!await this.supportPartialSchemaLoading(schemaContext)) {
+            const schemaJson = await this.getSchemaJson(schemaInfo.schemaKey, schemaContext);
+            return _Metadata_Schema__WEBPACK_IMPORTED_MODULE_4__.Schema.fromJson(schemaJson, schemaContext);
+        }
+        // Fetches the schema partials for the given schema key. The first item in the array is the
+        // actual schema props of the schema to load, the following items are schema props of referenced
+        // schema items that are needed to resolve the schema properly.
+        const schemaPartials = await this.getSchemaPartials(schemaInfo.schemaKey, schemaContext);
+        if (schemaPartials === undefined)
+            throw new _Exception__WEBPACK_IMPORTED_MODULE_3__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_3__.ECSchemaStatus.UnableToLocateSchema, `Could not locate the schema, ${schemaInfo.schemaKey.name}.${schemaInfo.schemaKey.version.toString()}`);
+        // Sort the partials in dependency order to ensure referenced schemas exist in the schema context
+        // when they get requested. Otherwise the context would call this method again and for referenced
+        // schemas, we would not want to request the whole schema props.
+        const sortedPartials = await this.sortSchemaPartials(schemaPartials, schemaContext);
+        for (const schemaProps of sortedPartials) {
+            await this.startLoadingPartialSchema(schemaProps, schemaContext);
+        }
+        const schema = await schemaContext.getCachedSchema(schemaInfo.schemaKey);
+        if (!schema)
+            throw new Error(`Schema ${schemaInfo.schemaKey.name} could not be found.`);
+        return schema;
+    }
+    /**
+     * Creates a SchemaProps object by loading the Schema information from the given SchemaContext.
+     * @param schemaKey The SchemaKey of the Schema whose props are to be retrieved.
+     * @param schemaContext The SchemaContext holding the Schema.
+     * @returns The SchemaProps object.
+     */
+    async createSchemaProps(schemaKey, schemaContext) {
+        const schemaInfo = await schemaContext.getSchemaInfo(schemaKey, _ECObjects__WEBPACK_IMPORTED_MODULE_2__.SchemaMatchType.Latest);
+        if (!schemaInfo)
+            throw new Error(`Schema ${schemaKey.name} could not be found.`);
+        const schemaProps = {
+            $schema: _Constants__WEBPACK_IMPORTED_MODULE_0__.ECSchemaNamespaceUris.SCHEMAURL3_2_JSON,
+            name: schemaKey.name,
+            alias: schemaInfo.alias,
+            version: schemaInfo.schemaKey.version.toString(),
+            references: [],
+            items: {}
+        };
+        if (!schemaProps.references)
+            throw new Error(`Schema references is undefined for the Schema ${schemaInfo.schemaKey.name}`);
+        schemaInfo.references.forEach((ref) => {
+            schemaProps.references.push({ name: ref.schemaKey.name, version: ref.schemaKey.version.toString() });
+        });
+        return schemaProps;
+    }
+    async startLoadingPartialSchema(schemaProps, schemaContext) {
+        if (schemaContext.schemaExists(_SchemaKey__WEBPACK_IMPORTED_MODULE_5__.SchemaKey.parseString(`${schemaProps.name}.${schemaProps.version}`))) {
+            return;
+        }
+        const controller = new _utils_SchemaLoadingController__WEBPACK_IMPORTED_MODULE_6__.SchemaLoadingController();
+        const schemaReader = new _IncrementalSchemaReader__WEBPACK_IMPORTED_MODULE_7__.IncrementalSchemaReader(schemaContext, true);
+        const schema = new _Metadata_Schema__WEBPACK_IMPORTED_MODULE_4__.Schema(schemaContext);
+        schema.setLoadingController(controller);
+        await schemaReader.readSchema(schema, schemaProps);
+        if (!this._options.loadPartialSchemaOnly)
+            controller.start(this.startLoadingFullSchema(schema));
+    }
+    async loadFullSchema(schema) {
+        const fullSchemaProps = await this.getSchemaJson(schema.schemaKey, schema.context);
+        const reader = new _IncrementalSchemaReader__WEBPACK_IMPORTED_MODULE_7__.IncrementalSchemaReader(schema.context, false);
+        await reader.readSchema(schema, fullSchemaProps, false);
+    }
+    async startLoadingFullSchema(schema) {
+        if (!schema.loadingController)
+            return;
+        // If the schema is already resolved, return it directly.
+        if (schema.loadingController.isComplete || schema.loadingController.inProgress) {
+            return;
+        }
+        // Since the schema relies on it's references, they get triggered to be resolved
+        // first by recursively calling this method. After all references has been resolved
+        // the schema itself gets resolved.
+        await Promise.all(schema.references.map(async (referenceSchema) => {
+            if (referenceSchema.loadingController && referenceSchema.loadingController.inProgress)
+                return referenceSchema.loadingController.wait();
+            else
+                return this.startLoadingFullSchema(referenceSchema);
+        }));
+        return this.loadFullSchema(schema);
+    }
+    async sortSchemaPartials(schemaPartials, schemaContext) {
+        const schemaInfos = [];
+        for (const schemaProps of schemaPartials) {
+            const schemaKey = _SchemaKey__WEBPACK_IMPORTED_MODULE_5__.SchemaKey.parseString(`${schemaProps.name}.${schemaProps.version}`);
+            const schemaInfo = await schemaContext.getSchemaInfo(schemaKey, _ECObjects__WEBPACK_IMPORTED_MODULE_2__.SchemaMatchType.Latest);
+            if (!schemaInfo)
+                throw new Error(`Schema ${schemaKey.name} could not be found.`);
+            schemaInfos.push({ ...schemaInfo, props: schemaProps });
+        }
+        const orderedSchemaInfos = _Deserialization_SchemaGraphUtil__WEBPACK_IMPORTED_MODULE_1__.SchemaGraphUtil.buildDependencyOrderedSchemaInfoList(schemaInfos);
+        return orderedSchemaInfos.map((schemaInfo) => schemaInfo.props);
+    }
+}
+/**
+ * Helper class to manage schema infos for a schema context.
+ */
+class SchemaInfoCache {
+    _schemaInfoCache;
+    _schemaInfoLoader;
+    constructor(schemaInfoLoader) {
+        this._schemaInfoCache = new WeakMap();
+        this._schemaInfoLoader = schemaInfoLoader;
+    }
+    async getSchemasByContext(context) {
+        if (!this._schemaInfoCache.has(context)) {
+            const schemaInfos = await this._schemaInfoLoader(context);
+            this._schemaInfoCache.set(context, Array.from(schemaInfos));
+        }
+        return this._schemaInfoCache.get(context);
+    }
+    async lookup(schemaKey, matchType, context) {
+        const contextSchemaInfos = await this.getSchemasByContext(context);
+        return contextSchemaInfos
+            ? contextSchemaInfos.find((schemaInfo) => schemaInfo.schemaKey.matches(schemaKey, matchType))
+            : undefined;
+    }
+    remove(schemaKey, context) {
+        const contextSchemaInfos = this._schemaInfoCache.get(context);
+        if (!contextSchemaInfos)
+            return;
+        const index = contextSchemaInfos.findIndex((schemaInfo) => schemaInfo.schemaKey.name === schemaKey.name);
+        if (index !== -1) {
+            contextSchemaInfos.splice(index, 1);
+        }
+    }
+}
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/IncrementalSchemaReader.js":
+/*!******************************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/IncrementalLoading/IncrementalSchemaReader.js ***!
+  \******************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   IncrementalSchemaReader: () => (/* binding */ IncrementalSchemaReader)
+/* harmony export */ });
+/* harmony import */ var _Deserialization_Helper__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../Deserialization/Helper */ "../../core/ecschema-metadata/lib/esm/Deserialization/Helper.js");
+/* harmony import */ var _Deserialization_JsonParser__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../Deserialization/JsonParser */ "../../core/ecschema-metadata/lib/esm/Deserialization/JsonParser.js");
+/* harmony import */ var _ECObjects__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../ECObjects */ "../../core/ecschema-metadata/lib/esm/ECObjects.js");
+/* harmony import */ var _Metadata_Class__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../Metadata/Class */ "../../core/ecschema-metadata/lib/esm/Metadata/Class.js");
+/* harmony import */ var _Metadata_SchemaItem__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../Metadata/SchemaItem */ "../../core/ecschema-metadata/lib/esm/Metadata/SchemaItem.js");
+/* harmony import */ var _utils_SchemaLoadingController__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/SchemaLoadingController */ "../../core/ecschema-metadata/lib/esm/utils/SchemaLoadingController.js");
+
+
+
+
+
+
+/**
+ * Internal helper class to read schema information incrementally. It's based on the [[SchemaReadHelper]]
+ * but overrides a few methods to support the incremental schema loading case.
+ * @internal
+ */
+class IncrementalSchemaReader extends _Deserialization_Helper__WEBPACK_IMPORTED_MODULE_0__.SchemaReadHelper {
+    _incremental;
+    /**
+     * Initializes a new [[IncrementalSchemaReader]] instance.
+     * @param schemaContext The [[SchemaContext]] used to load the schemas.
+     * @param incremental Indicates that the Schema should be read incrementally.
+     * Pass false to load the full schema without an incremental/partial load.
+     */
+    constructor(schemaContext, incremental) {
+        super(_Deserialization_JsonParser__WEBPACK_IMPORTED_MODULE_1__.JsonParser, schemaContext);
+        this._incremental = incremental;
+    }
+    /**
+     * Indicates that a given [[SchemaItem]] has been fully loaded.
+     * @param schemaItem The SchemaItem to check.
+     * @returns True if the item has been loaded, false if still in progress.
+     */
+    isSchemaItemLoaded(schemaItem) {
+        return schemaItem !== undefined
+            && schemaItem.loadingController !== undefined
+            && schemaItem.loadingController.isComplete;
+    }
+    /**
+     * Starts loading the [[SchemaItem]] identified by the given name and itemType.
+     * @param schema The [[Schema]] that contains the SchemaItem.
+     * @param name The name of the SchemaItem to load.
+     * @param itemType The SchemaItem type name of the item to load.
+     * @param schemaItemObject The object accepting the SchemaItem data.
+     * @returns A promise that resolves to the loaded SchemaItem instance. Can be undefined.
+     */
+    async loadSchemaItem(schema, name, itemType, schemaItemObject) {
+        const schemaItem = await super.loadSchemaItem(schema, name, itemType, this._incremental ? undefined : schemaItemObject);
+        // In incremental mode, we only load the stubs of the classes. These include the modifier and base classes.
+        // The fromJSON method of the actual class instances may complain about missing properties in the props, so
+        // calling the fromJSON on the ECClass ensures only the bare minimum is loaded.
+        if (this._incremental && schemaItemObject && schemaItem) {
+            if (schemaItem.schemaItemType === _ECObjects__WEBPACK_IMPORTED_MODULE_2__.SchemaItemType.KindOfQuantity) {
+                _Metadata_SchemaItem__WEBPACK_IMPORTED_MODULE_4__.SchemaItem.prototype.fromJSONSync.call(schemaItem, schemaItemObject);
+            }
+            else {
+                schemaItem.fromJSONSync(schemaItemObject);
+            }
+        }
+        this.schemaItemLoading(schemaItem);
+        return schemaItem;
+    }
+    schemaItemLoading(schemaItem) {
+        if (schemaItem === undefined)
+            return;
+        if (schemaItem.loadingController === undefined) {
+            const controller = new _utils_SchemaLoadingController__WEBPACK_IMPORTED_MODULE_5__.SchemaLoadingController();
+            schemaItem.setLoadingController(controller);
+        }
+        if (_Metadata_Class__WEBPACK_IMPORTED_MODULE_3__.ECClass.isECClass(schemaItem)
+            || schemaItem.schemaItemType === _ECObjects__WEBPACK_IMPORTED_MODULE_2__.SchemaItemType.KindOfQuantity
+            || schemaItem.schemaItemType === _ECObjects__WEBPACK_IMPORTED_MODULE_2__.SchemaItemType.Format)
+            schemaItem.loadingController.isComplete = !this._incremental;
+        else
+            schemaItem.loadingController.isComplete = true;
+    }
+}
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaItemParsers.js":
+/*!************************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaItemParsers.js ***!
+  \************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   KindOfQuantityParser: () => (/* binding */ KindOfQuantityParser),
+/* harmony export */   SchemaItemParser: () => (/* binding */ SchemaItemParser)
+/* harmony export */ });
+/* harmony import */ var _ECObjects__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../ECObjects */ "../../core/ecschema-metadata/lib/esm/ECObjects.js");
+/* harmony import */ var _Metadata_OverrideFormat__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../Metadata/OverrideFormat */ "../../core/ecschema-metadata/lib/esm/Metadata/OverrideFormat.js");
+/* harmony import */ var _Metadata_SchemaItem__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../Metadata/SchemaItem */ "../../core/ecschema-metadata/lib/esm/Metadata/SchemaItem.js");
+/* harmony import */ var _SchemaParser__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./SchemaParser */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaParser.js");
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+
+
+
+/**
+ * Parses SchemaItemProps JSON returned from an ECSql query and returns the correct SchemaItemProps JSON.
+ * This is necessary as a small amount information (ie. CustomAttribute data) returned from the iModelDb
+ * is in a different format than is required for a SchemaItemProps JSON object.
+ * @internal
+ */
+class SchemaItemParser {
+    _schema;
+    _context;
+    /**
+     * Initializes a new SchemaItemParser.
+     * @param schemaName The name the Schema containing the SchemaItems.
+     * @param context The SchemaContext containing the Schema.
+     */
+    constructor(schemaName, context) {
+        this._schema = schemaName;
+        this._context = context;
+    }
+    /**
+     * Parses the given SchemaItemProps JSON returned from an ECSql query.
+     * @param data The SchemaItemProps JSON as returned from an iModelDb.
+     * @returns The corrected SchemaItemProps Json.
+     */
+    async parse(data) {
+        const props = data;
+        props.schemaItemType = (0,_ECObjects__WEBPACK_IMPORTED_MODULE_0__.parseSchemaItemType)(data.schemaItemType);
+        props.customAttributes = props.customAttributes ? props.customAttributes.map((attr) => { return (0,_SchemaParser__WEBPACK_IMPORTED_MODULE_3__.parseCustomAttribute)(attr); }) : undefined;
+        if (!props.customAttributes || props.customAttributes.length === 0)
+            delete props.customAttributes;
+        return props;
+    }
+    /**
+     * Helper method to resolve the SchemaItem's full name from the given rawTypeName.
+     * If the SchemaItem is defined in the same Schema from which it is referenced,
+     * the rawTypeName will be SchemaItem name ('PhysicalElement'). Otherwise,
+     * the rawTypeName will have the schema alias ('bis:PhysicalElement').
+     * @param rawTypeName The name or aliased name of the SchemaItem.
+     * @returns The full name of the SchemaItem, ie. 'BisCore.PhysicalElement'
+     */
+    async getQualifiedTypeName(rawTypeName) {
+        const nameParts = rawTypeName.split(":");
+        if (nameParts.length !== 2) {
+            const [schemaName, itemName] = _Metadata_SchemaItem__WEBPACK_IMPORTED_MODULE_2__.SchemaItem.parseFullName(rawTypeName);
+            if (!schemaName || schemaName === '')
+                return `${this._schema}.${itemName}`;
+            return rawTypeName;
+        }
+        const resolvedName = await this.resolveNameFromAlias(nameParts[0].toLocaleLowerCase());
+        if (!resolvedName)
+            throw new Error(`No valid schema found for alias '${nameParts[0]}'`);
+        return `${resolvedName}.${nameParts[1]}`;
+    }
+    async resolveNameFromAlias(alias) {
+        for (const schema of this._context.getKnownSchemas()) {
+            if (schema.alias === alias)
+                return schema.schemaKey.name;
+        }
+        return undefined;
+    }
+}
+/**
+ * Parses KindOfQuantityProps JSON returned from an ECSql query and returns the correct KindOfQuantityProps JSON.
+ * This is necessary as a small amount information (ie. unqualified type names of presentationUnits) returned from
+ * the iModelDb is in a different format than is required for a KindOfQuantityProps JSON object.
+ * @internal
+ */
+class KindOfQuantityParser extends SchemaItemParser {
+    /**
+     * Parses the given KindOfQuantityProps JSON returned from an ECSql query.
+     * @param data The KindOfQuantityProps JSON as returned from an iModelDb.
+     * @returns The corrected KindOfQuantityProps Json.
+     */
+    async parse(data) {
+        const mutableProps = await super.parse(data);
+        if (mutableProps.persistenceUnit) {
+            mutableProps.persistenceUnit = await this.getQualifiedTypeName(mutableProps.persistenceUnit);
+        }
+        mutableProps.presentationUnits = await this.parsePresentationUnits(mutableProps);
+        return mutableProps;
+    }
+    async parsePresentationUnits(props) {
+        const presentationUnits = [];
+        if (!props.presentationUnits)
+            return [];
+        for (const presentationUnit of props.presentationUnits) {
+            const presFormatOverride = _Metadata_OverrideFormat__WEBPACK_IMPORTED_MODULE_1__.OverrideFormat.parseFormatString(presentationUnit);
+            const formatString = await this.createOverrideFormatString(presFormatOverride);
+            presentationUnits.push(formatString);
+        }
+        ;
+        return presentationUnits;
+    }
+    async createOverrideFormatString(overrideFormatProps) {
+        let formatFullName = await this.getQualifiedTypeName(overrideFormatProps.name);
+        if (overrideFormatProps.precision)
+            formatFullName += `(${overrideFormatProps.precision.toString()})`;
+        if (undefined === overrideFormatProps.unitAndLabels)
+            return formatFullName;
+        for (const [unit, unitLabel] of overrideFormatProps.unitAndLabels) {
+            const unitFullName = await this.getQualifiedTypeName(unit);
+            if (undefined === unitLabel)
+                formatFullName += `[${unitFullName}]`;
+            else
+                formatFullName += `[${unitFullName}|${unitLabel}]`;
+        }
+        return formatFullName;
+    }
+}
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaItemQueries.js":
+/*!************************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaItemQueries.js ***!
+  \************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   SchemaItemQueries: () => (/* binding */ SchemaItemQueries)
+/* harmony export */ });
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+/************************************************************************************
+ * All SchemaItem queries for each SchemaItemType are defined here. These queries
+ * are shared for both 'partial schema' and 'full schema' queries.
+ ***********************************************************************************/
+/**
+ * Query for SchemaItemType KindOfQuantity data.
+ * @param singleSchema Indicates if a filter and join for a single Schema should be applied.
+ */
+const kindOfQuantity = (singleSchema) => `
+SELECT
+  [koq].[Schema].[Id] AS [SchemaId],
+  json_object (
+    'schemaItemType', 'KindOfQuantity',
+    'name', [koq].[Name],
+    'label', [koq].[DisplayLabel],
+    'description', [koq].[Description]
+    ${singleSchema ? `
+    ,'relativeError', [koq].[RelativeError],
+    'persistenceUnit', [koq].[PersistenceUnit],
+    'presentationUnits', (
+        SELECT json_group_array(js."value")
+        FROM [meta].[KindOfQuantityDef] [koq1], json1.json_each([PresentationUnits]) js
+        WHERE [koq1].[ECInstanceId] = [koq].[ECInstanceId]
+    ) ` : ""}
+  ) as [item]
+FROM
+  [meta].[KindOfQuantityDef] [koq]
+${singleSchema ? `
+JOIN
+  [meta].[ECSchemaDef] [schema] ON [schema].[ECInstanceId] = [koq].[Schema].[Id]
+WHERE [schema].[Name] = :schemaName
+` : ""}
+`;
+/**
+ * Query for SchemaItemType PropertyCategory data.
+ * @param singleSchema Indicates if a filter and join for a single Schema should be applied.
+ */
+const propertyCategory = (singleSchema) => `
+SELECT
+  [pc].[Schema].[Id] AS [SchemaId],
+  json_object (
+    'schemaItemType', 'PropertyCategory',
+    'name', [pc].[Name],
+    'label', [pc].[DisplayLabel],
+    'description', [pc].[Description],
+    'priority', [pc].[Priority]
+  ) as [item]
+FROM
+  [meta].[PropertyCategoryDef] [pc]
+${singleSchema ? `
+JOIN
+  [meta].[ECSchemaDef] [schema] ON [schema].[ECInstanceId] = [pc].[Schema].[Id]
+WHERE [schema].[Name] = :schemaName
+` : ""}
+`;
+/**
+ * Query for SchemaItemType Enumeration data.
+ * @param singleSchema Indicates if a filter and join for a single Schema should be applied.
+ */
+const enumeration = (singleSchema) => `
+SELECT
+  [ed].[Schema].[Id] AS [SchemaId],
+  json_object (
+    'schemaItemType', 'Enumeration',
+    'name', [ed].[Name],
+    'label', [ed].[DisplayLabel],
+    'description', [ed].[Description],
+    'type', IIF([ed].[Type] = 1281, 'int', IIF([ed].[Type] = 2305, 'string', null)),
+    'isStrict', IIF([ed].[IsStrict] = 1, json('true'), json('false')),
+    'enumerators', (
+      SELECT json_group_array(json(json_object(
+        'name', json_extract(js."value", '$.Name'),
+        'value', IFNULL(json_extract(js."value", '$.StringValue'), (json_extract(js."value", '$.IntValue'))),
+        'label', json_extract(js."value", '$.DisplayLabel'),
+        'description', json_extract(js."value", '$.Description')
+      )))
+      FROM [meta].[ECEnumerationDef] [enumerationDef], json1.json_each([EnumValues]) js
+      WHERE [enumerationDef].[ECInstanceId] = [ed].[ECInstanceId]
+    )
+  ) as [item]
+FROM
+  [meta].[ECEnumerationDef] [ed]
+${singleSchema ? `
+JOIN
+  [meta].[ECSchemaDef] [schema] ON [schema].[ECInstanceId] = [ed].[Schema].[Id]
+WHERE [schema].[Name] = :schemaName` : ""}
+`;
+/**
+ * Query for SchemaItemType Unit data.
+ * @param singleSchema Indicates if a filter and join for a single Schema should be applied.
+ */
+const unit = (singleSchema) => `
+SELECT
+  [ud].[Schema].[Id] AS [SchemaId],
+  json_object (
+    'schemaItemType', 'Unit',
+    'name', [ud].[Name],
+    'label', [ud].[DisplayLabel],
+    'description', [ud].[Description],
+    'definition', [ud].[Definition],
+    'numerator', IIF([ud].[Numerator] IS NULL, NULL, json(format('%.16g', [ud].[Numerator]))),
+    'denominator', IIF([ud].[Denominator] IS NULL, NULL, json(format('%.16g', [ud].[Denominator]))),
+    'offset', IIF([ud].[Offset] IS NULL, NULL, json(format('%!.15f', [ud].[Offset]))),
+    'unitSystem', CONCAT([uss].[Name],'.', [usd].[Name]),
+    'phenomenon', CONCAT([ps].[Name],'.', [pd].[Name])
+  ) as item
+FROM
+  [meta].[UnitDef] [ud]
+${singleSchema ? `
+JOIN
+  [meta].[ECSchemaDef] [schema] ON [schema].[ECInstanceId] = [ud].[Schema].[Id]` : ""}
+JOIN [meta].[UnitSystemDef] [usd]
+  ON [usd].[ECInstanceId] = [ud].[UnitSystem].[Id]
+JOIN [meta].[ECSchemaDef] [uss]
+  ON [uss].[ECInstanceId] = [usd].[Schema].[Id]
+JOIN [meta].[PhenomenonDef] [pd]
+  ON [pd].[ECInstanceId] = [ud].[Phenomenon].[Id]
+JOIN [meta].[ECSchemaDef] [ps]
+  ON [ps].[ECInstanceId] = [pd].[Schema].[Id]
+WHERE
+  ${singleSchema ? `
+  [schema].[Name] = :schemaName AND` : ""}
+  [ud].[IsConstant] = 0 AND
+  [ud].[InvertingUnit] IS NULL
+`;
+/**
+ * Query for SchemaItemType InvertedUnit data.
+ * @param singleSchema Indicates if a filter and join for a single Schema should be applied.
+ */
+const invertedUnit = (singleSchema) => `
+SELECT
+  [ud].[Schema].[Id] AS [SchemaId],
+  json_object (
+    'schemaItemType', 'InvertedUnit',
+    'name', [ud].[Name],
+    'label', [ud].[DisplayLabel],
+    'description', [ud].[Description],
+    'unitSystem', CONCAT([systemSchema].[Name],'.', [usd].[Name]),
+    'invertsUnit', IIF([iud].[Name] IS NULL, null, CONCAT([ius].[Name],'.', [iud].[Name]))
+  ) as [item]
+FROM
+  [meta].[UnitDef] [ud]
+${singleSchema ? `
+JOIN
+  [meta].[ECSchemaDef] [schema] ON [schema].[ECInstanceId] = [ud].[Schema].[Id]` : ""}
+JOIN [meta].[UnitSystemDef] [usd]
+  ON [usd].[ECInstanceId] = [ud].[UnitSystem].[Id]
+JOIN [meta].[ECSchemaDef] [systemSchema]
+  ON [systemSchema].[ECInstanceId] = [usd].[Schema].[Id]
+LEFT JOIN [meta].[UnitDef] [iud]
+  ON [iud].[ECInstanceId] = [ud].[InvertingUnit].[Id]
+LEFT JOIN [meta].[ECSchemaDef] [ius]
+  ON [ius].[ECInstanceId] = [iud].[Schema].[Id]
+WHERE
+  ${singleSchema ? `
+  [schema].[Name] = :schemaName AND` : ""}
+  [ud].[IsConstant] = 0 AND
+  [ud].[InvertingUnit] IS NOT NULL
+`;
+/**
+ * Query for SchemaItemType Constant data.
+ * @param singleSchema Indicates if a filter and join for a single Schema should be applied.
+ */
+const constant = (singleSchema) => `
+SELECT
+  [cd].[Schema].[Id] AS [SchemaId],
+  json_object(
+    'schemaItemType', 'Constant',
+    'name', [cd].[Name],
+    'label', [cd].[DisplayLabel],
+    'description', [cd].[Description],
+    'definition', [cd].[Definition],
+    'numerator', IIF([cd].[Numerator] IS NULL, NULL, json(format('%.16g', [cd].[Numerator]))),
+    'denominator', IIF([cd].[Denominator] IS NULL, NULL, json(format('%.16g', [cd].[Denominator]))),
+    'phenomenon', CONCAT([phenomSchema].[Name],'.', [phenomDef].[Name])
+  ) as item
+FROM
+  [meta].[UnitDef] [cd]
+${singleSchema ? `
+JOIN
+  [meta].[ECSchemaDef] [schema] ON [schema].[ECInstanceId] = [cd].[Schema].[Id]` : ""}
+JOIN [meta].[PhenomenonDef] [phenomDef]
+  ON [phenomDef].[ECInstanceId] = [cd].[Phenomenon].[Id]
+JOIN [meta].[ECSchemaDef] [phenomSchema]
+  ON [phenomSchema].[ECInstanceId] = [phenomDef].[Schema].[Id]
+WHERE
+  ${singleSchema ? `
+  [schema].[Name] = :schemaName AND` : ""}
+  [cd].[IsConstant] = 1
+`;
+/**
+ * Query for SchemaItemType UnitSystem data.
+ * @param singleSchema Indicates if a filter and join for a single Schema should be applied.
+ */
+const unitSystem = (singleSchema) => `
+SELECT
+  [us].[Schema].[Id] AS [SchemaId],
+  json_object (
+    'schemaItemType', 'UnitSystem',
+    'name', [us].[Name],
+    'label', [us].[DisplayLabel],
+    'description', [us].[Description]
+  ) as [item]
+FROM
+  [meta].[UnitSystemDef] [us]
+${singleSchema ? `
+JOIN
+  [meta].[ECSchemaDef] [schema] ON [schema].[ECInstanceId] = [us].[Schema].[Id]
+WHERE [schema].[Name] = :schemaName` : ""}
+`;
+/**
+ * Query for SchemaItemType Phenomenon data.
+ * @param singleSchema Indicates if a filter and join for a single Schema should be applied.
+ */
+const phenomenon = (singleSchema) => `
+SELECT
+  [pd].[Schema].[Id] AS [SchemaId],
+  json_object(
+    'schemaItemType', 'Phenomenon',
+    'name', [pd].[Name],
+    'label', [pd].[DisplayLabel],
+    'description', [pd].[Description],
+    'definition', [pd].[Definition]
+  ) as [item]
+FROM
+  [meta].[PhenomenonDef] [pd]
+${singleSchema ? `
+JOIN
+  [meta].[ECSchemaDef] [schema] ON [schema].[ECInstanceId] = [pd].[Schema].[Id]
+WHERE [schema].[Name] = :schemaName` : ""}
+`;
+/**
+ * Query for SchemaItemType Format data.
+ * @param singleSchema Indicates if a filter and join for a single Schema should be applied.
+ */
+const format = (singleSchema) => `
+SELECT
+  [fd].[Schema].[Id] AS [SchemaId],
+  json_object(
+    'schemaItemType', 'Format',
+    'name', [fd].[Name],
+    'label', [fd].[DisplayLabel],
+    'description', [fd].[Description],
+    'type', json_extract([fd].[NumericSpec], '$.type'),
+    'precision', json_extract([fd].[NumericSpec], '$.precision'),
+    'roundFactor', json_extract([fd].[NumericSpec], '$.roundFactor'),
+    'minWidth', json_extract([fd].[NumericSpec], '$.minWidth'),
+    'showSignOption', json_extract([fd].[NumericSpec], '$.showSignOption'),
+    'decimalSeparator', json_extract([fd].[NumericSpec], '$.decimalSeparator'),
+    'thousandSeparator', json_extract([fd].[NumericSpec], '$.thousandSeparator'),
+    'uomSeparator', json_extract([fd].[NumericSpec], '$.uomSeparator'),
+    'scientificType', json_extract([fd].[NumericSpec], '$.scientificType'),
+    'stationOffsetSize', json_extract([fd].[NumericSpec], '$.stationOffsetSize'),
+    'stationSeparator', json_extract([fd].[NumericSpec], '$.stationSeparator'),
+    'formatTraits', json_extract([fd].[NumericSpec], '$.formatTraits')
+    ${singleSchema ? `
+    ,'composite', (
+      SELECT
+        json_object(
+          'spacer', json_extract([fd1].[CompositeSpec], '$.spacer'),
+          'includeZero', json(IIF(json_extract([fd1].[CompositeSpec], '$.includeZero') = 1, 'true', IIF(json_extract([fd1].[CompositeSpec], '$.includeZero') = 0, 'false', null))),
+          'units', (
+            SELECT json_group_array(json(json_object(
+              'name', CONCAT([sd].[Name], '.', [ud].[Name]),
+              'label', [fud].[Label]
+            )))
+            FROM [meta].[FormatDef] [fd2]
+              LEFT JOIN [meta].[FormatCompositeUnitDef] [fud] ON [fud].[Format].[Id] = [fd2].[ECInstanceId]
+              LEFT JOIN [meta].[UnitDef] [ud] ON [ud].[ECInstanceId] = [fud].[Unit].[Id]
+              INNER JOIN [meta].[ECSchemaDef] [sd] ON [sd].[ECInstanceId] = [ud].[Schema].[Id]
+            WHERE [fd2].[ECInstanceId] = [fd1].[ECInstanceId]
+          )
+        )
+      FROM [meta].[FormatDef] [fd1]
+      WHERE [fd1].[ECInstanceId]= [fd].[ECInstanceId] AND [fd1].[CompositeSpec] IS NOT NULL
+    )` : ""}
+) AS item
+FROM
+  [meta].[FormatDef] [fd]
+${singleSchema ? `
+JOIN
+  [meta].[ECSchemaDef] [schema] ON [schema].[ECInstanceId] = [fd].[Schema].[Id]
+WHERE [schema].[Name] = :schemaName` : ""}
+`;
+/**
+ * Queries for each SchemaItemType
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const SchemaItemQueries = {
+    kindOfQuantity,
+    propertyCategory,
+    enumeration,
+    unit,
+    invertedUnit,
+    constant,
+    unitSystem,
+    phenomenon,
+    format
+};
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaParser.js":
+/*!*******************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaParser.js ***!
+  \*******************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   SchemaParser: () => (/* binding */ SchemaParser),
+/* harmony export */   parseCustomAttribute: () => (/* binding */ parseCustomAttribute)
+/* harmony export */ });
+/* harmony import */ var _Constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../Constants */ "../../core/ecschema-metadata/lib/esm/Constants.js");
+/* harmony import */ var _ECObjects__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ECObjects */ "../../core/ecschema-metadata/lib/esm/ECObjects.js");
+/* harmony import */ var _ClassParsers__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ClassParsers */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/ClassParsers.js");
+/* harmony import */ var _SchemaItemParsers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./SchemaItemParsers */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaItemParsers.js");
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+
+
+
+function clean(_key, value) {
+    return value === null ? undefined : value;
+}
+/**
+ * Parses SchemaProps JSON returned from an ECSql query and returns the correct SchemaProps JSON object.
+ * This is necessary as a small amount information (ie. CustomAttributes, unqualified type names, etc.)
+ * returned from the iModelDb is in a different format than is required for a given Schema or
+ * SchemaItemProps JSON object.
+ * @internal
+ */
+class SchemaParser {
+    /**
+     * Corrects the SchemaProps JSON returned from the query to a proper SchemaProps
+     * JSON object.
+     * @param schema The SchemaProps JSON object to parse.
+     * @param context The SchemaContext that will contain the schema and it's references.
+     * @returns The corrected SchemaProps JSON.
+     */
+    static async parse(schema, context) {
+        const props = schema;
+        props.$schema = _Constants__WEBPACK_IMPORTED_MODULE_0__.ECSchemaNamespaceUris.SCHEMAURL3_2_JSON,
+            props.customAttributes = props.customAttributes ? props.customAttributes.map((attr) => { return parseCustomAttribute(attr); }) : undefined;
+        props.label = props.label === null ? undefined : props.label;
+        props.description = props.description === null ? undefined : props.description;
+        if (props.items) {
+            props.items = await this.parseItems(props.items, props.name, context);
+        }
+        if (!props.customAttributes || props.customAttributes.length === 0)
+            delete props.customAttributes;
+        const cleaned = JSON.parse(JSON.stringify(props, clean));
+        return cleaned;
+    }
+    /**
+     * Parse the given SchemaItemProps array, as returned from an ECSql query, and returns the corrected SchemaItemProps.
+     * @param schemaItems The SchemaItemProps array returned from an iModelDb.
+     * @param schemaName The name of the Schema to which the SchemaItemProps belong.
+     * @param context The SchemaContext containing the Schema.
+     * @returns The corrected SchemaItemProps.
+     */
+    static async parseSchemaItems(schemaItems, schemaName, context) {
+        const items = [];
+        for (const item of schemaItems) {
+            const props = await this.parseItem(item, schemaName, context);
+            const cleaned = JSON.parse(JSON.stringify(props, clean));
+            items.push(cleaned);
+        }
+        return items.length > 0 ? items : undefined;
+    }
+    static async parseItems(schemaItemProps, schemaName, context) {
+        const items = {};
+        for (const itemProps of schemaItemProps) {
+            const props = await this.parseItem(itemProps, schemaName, context);
+            items[props.name] = props;
+            delete props.name;
+        }
+        return Object.keys(items).length > 0 ? items : undefined;
+    }
+    static async parseItem(props, schemaName, context) {
+        const schemaItem = "string" === typeof (props) ? JSON.parse(props) : props;
+        const type = (0,_ECObjects__WEBPACK_IMPORTED_MODULE_1__.parseSchemaItemType)(schemaItem.schemaItemType);
+        switch (type) {
+            case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.KindOfQuantity:
+                const koqParser = new _SchemaItemParsers__WEBPACK_IMPORTED_MODULE_3__.KindOfQuantityParser(schemaName, context);
+                return koqParser.parse(schemaItem);
+            case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.EntityClass:
+            case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.StructClass:
+                const classParser = new _ClassParsers__WEBPACK_IMPORTED_MODULE_2__.ClassParser(schemaName, context);
+                return classParser.parse(schemaItem);
+            case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.RelationshipClass:
+                const relationshipParser = new _ClassParsers__WEBPACK_IMPORTED_MODULE_2__.RelationshipClassParser(schemaName, context);
+                return relationshipParser.parse(schemaItem);
+            case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.Mixin:
+                const mixinParser = new _ClassParsers__WEBPACK_IMPORTED_MODULE_2__.MixinParser(schemaName, context);
+                return mixinParser.parse(schemaItem);
+            case _ECObjects__WEBPACK_IMPORTED_MODULE_1__.SchemaItemType.CustomAttributeClass:
+                const caParser = new _ClassParsers__WEBPACK_IMPORTED_MODULE_2__.CustomAttributeClassParser(schemaName, context);
+                return caParser.parse(schemaItem);
+            default:
+                const itemParser = new _SchemaItemParsers__WEBPACK_IMPORTED_MODULE_3__.SchemaItemParser(schemaName, context);
+                return itemParser.parse(schemaItem);
+        }
+    }
+}
+/**
+ * Utility method to parse CustomAttribute data retrieved from a ECSql query.
+ * @param customAttribute CustomAttribute data as retrieved from an iModel query.
+ * @returns The CustomAttribute instance.
+ * @internal
+ */
+function parseCustomAttribute(customAttribute) {
+    return {
+        ...customAttribute[customAttribute.ecClass],
+        className: `${(customAttribute.ecSchema).split('.')[0]}.${customAttribute.ecClass}`,
+    };
+}
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaStubQueries.js":
+/*!************************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaStubQueries.js ***!
+  \************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ecsqlQueries: () => (/* binding */ ecsqlQueries),
+/* harmony export */   modifier: () => (/* binding */ modifier),
+/* harmony export */   strength: () => (/* binding */ strength),
+/* harmony export */   strengthDirection: () => (/* binding */ strengthDirection)
+/* harmony export */ });
+/* harmony import */ var _SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./SchemaItemQueries */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/SchemaItemQueries.js");
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+const modifier = (alias) => {
+    return `
+    CASE
+      WHEN [${alias}].[modifier] = 0 THEN 'None'
+      WHEN [${alias}].[modifier] = 1 THEN 'Abstract'
+      WHEN [${alias}].[modifier] = 2 THEN 'Sealed'
+      ELSE NULL
+    END
+  `;
+};
+const strength = (alias) => {
+    return `
+    CASE
+      WHEN [${alias}].[RelationshipStrength] = 0 THEN 'Referencing'
+      WHEN [${alias}].[RelationshipStrength] = 1 THEN 'Holding'
+      WHEN [${alias}].[RelationshipStrength] = 2 THEN 'Embedding'
+      ELSE NULL
+    END
+  `;
+};
+const strengthDirection = (alias) => {
+    return `
+    CASE
+      WHEN [${alias}].[RelationshipStrengthDirection] = 1 THEN 'Forward'
+      WHEN [${alias}].[RelationshipStrengthDirection] = 2 THEN 'Backward'
+      ELSE NULL
+    END
+  `;
+};
+const withAppliesTo = `
+  AppliesToCTE AS (
+    SELECT
+      [mixinAppliesTo].[ECInstanceId] AS [AppliesToId],
+      [appliesToSchema].[name] as [AppliesToSchema],
+      json_extract(XmlCAToJson([ca].[Class].[Id], [ca].[Instance]), '$.IsMixin.AppliesToEntityClass') AS [AppliesTo]
+    FROM [meta].[CustomAttribute] [ca]
+    JOIN [meta].[ECClassDef] [mixinAppliesTo]
+      ON [mixinAppliesTo].[ECInstanceId] = [ca].[ContainerId]
+    JOIN [meta].[ECSchemaDef] [appliesToSchema]
+      ON [appliesToSchema].[ECInstanceId] = [mixinAppliesTo].[Schema].[Id]
+    WHERE [ca].[ContainerType] = 30
+      AND json_extract(XmlCAToJson([ca].[Class].[Id], [ca].[Instance]), '$.ecClass') = 'IsMixin'
+  )
+`;
+const withSchemaReferences = `
+  SchemaReferences AS (
+    SELECT
+      [ref].[SourceECInstanceId] AS [SchemaId],
+      CONCAT([Name],'.',[VersionMajor],'.',[VersionWrite],'.',[VersionMinor]) AS [fullName]
+    FROM
+      [meta].[ECSchemaDef] AS [refSchema]
+    INNER JOIN [meta].[SchemaHasSchemaReferences] [ref]
+      ON [ref].[TargetECInstanceId] = [refSchema].[ECInstanceId]
+  )
+`;
+const customAttributeQuery = `
+  SELECT
+    [Schema].[Id] AS [SchemaId],
+    json_object(
+      'name', [class].[Name],
+      'schemaItemType', 'CustomAttributeClass',
+      'modifier', ${modifier("class")},
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'appliesTo', [class].[CustomAttributeContainerType],
+      'baseClasses', (
+        SELECT
+          json_group_array(json(json_object(
+            'schema', ec_classname([baseClass].[ECInstanceId], 's'),
+            'name', [baseClass].[Name],
+            'schemaItemType', 'CustomAttributeClass',
+            'modifier', ${modifier("baseClass")},
+            'label', [baseClass].[DisplayLabel],
+            'description', [baseClass].[Description],
+            'appliesTo', [baseClass].[CustomAttributeContainerType]
+          )))
+        FROM
+          [meta].[ECClassDef] [baseClass]
+        INNER JOIN [meta].[ClassHasAllBaseClasses] [baseClassMap]
+          ON [baseClassMap].[TargetECInstanceId] = [baseclass].[ECInstanceId]
+        WHERE [baseClassMap].[SourceECInstanceId] = [class].[ECInstanceId]
+      )
+    ) AS [item]
+  FROM [meta].[ECClassDef] [class]
+  WHERE [class].[Type] = 3
+`;
+const structQuery = `
+  SELECT
+    [Schema].[Id] AS [SchemaId],
+    json_object(
+      'name', [class].[Name],
+      'schemaItemType', 'StructClass',
+      'modifier', ${modifier("class")},
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'baseClasses', (
+        SELECT
+          json_group_array(json(json_object(
+            'schema', ec_classname([baseClass].[ECInstanceId], 's'),
+            'name', [baseClass].[Name],
+            'schemaItemType', 'StructClass',
+            'modifier', ${modifier("baseClass")},
+            'label', [baseClass].[DisplayLabel],
+            'description', [baseClass].[Description]
+          )))
+        FROM
+          [meta].[ECClassDef] [baseClass]
+        INNER JOIN [meta].[ClassHasAllBaseClasses] [baseClassMap]
+          ON [baseClassMap].[TargetECInstanceId] = [baseclass].[ECInstanceId]
+        WHERE [baseClassMap].[SourceECInstanceId] = [class].[ECInstanceId]
+      )
+    ) AS [item]
+  FROM [meta].[ECClassDef] [class]
+  WHERE [class].[Type] = 2
+`;
+const relationshipQuery = `
+  SELECT
+    [Schema].[Id] AS [SchemaId],
+    json_object(
+      'name', [class].[Name],
+      'schemaItemType', 'RelationshipClass',
+      'modifier', ${modifier("class")},
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'strength', ${strength("class")},
+      'strengthDirection', ${strengthDirection("class")},
+      'baseClasses', (
+        SELECT
+          json_group_array(json(json_object(
+            'schema', ec_classname([baseClass].[ECInstanceId], 's'),
+            'name', [baseClass].[Name],
+            'schemaItemType', 'RelationshipClass',
+            'modifier', ${modifier("baseClass")},
+            'label', [baseClass].[DisplayLabel],
+            'description', [baseClass].[Description],
+            'strength', ${strength("baseClass")},
+            'strengthDirection', ${strengthDirection("baseClass")}
+          )))
+        FROM
+          [meta].[ECClassDef] [baseClass]
+        INNER JOIN [meta].[ClassHasAllBaseClasses] [baseClassMap]
+          ON [baseClassMap].[TargetECInstanceId] = [baseclass].[ECInstanceId]
+        WHERE [baseClassMap].[SourceECInstanceId] = [class].[ECInstanceId]
+      )
+    ) AS [item]
+  FROM [meta].[ECClassDef] [class]
+  WHERE [class].[Type] = 1
+`;
+const entityQuery = `
+  SELECT
+    [Schema].[Id] AS [SchemaId],
+    json_object(
+      'name', [class].[Name],
+      'schemaItemType', 'EntityClass',
+      'modifier', ${modifier("class")},
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'baseClasses', (
+        SELECT
+          json_group_array(json(json_object(
+            'schema', ec_classname([baseClass].[ECInstanceId], 's'),
+            'name', [baseClass].[Name],
+            'schemaItemType', 'EntityClass',
+            'modifier', ${modifier("baseClass")},
+            'label', [baseClass].[DisplayLabel],
+            'description', [baseClass].[Description]
+          )))
+        FROM
+          [meta].[ECClassDef] [baseClass]
+        INNER JOIN [meta].[ClassHasAllBaseClasses] [baseClassMap]
+          ON [baseClassMap].[TargetECInstanceId] = [baseclass].[ECInstanceId]
+        WHERE [baseClassMap].[SourceECInstanceId] = [class].[ECInstanceId]
+          AND NOT EXISTS(SELECT 1 FROM [meta].[ClassCustomAttribute] [ca] WHERE [baseClass].[ECInstanceId] = [ca].[Class].[Id]
+            AND [ca].[CustomAttributeClass].[Id] Is ([CoreCA].[IsMixin]))
+        ),
+      'mixins', (
+        SELECT
+          json_group_array(json(json_object(
+            'schema', ec_classname([baseClass].[ECInstanceId], 's'),
+            'name', [baseClass].[Name],
+            'schemaItemType', 'Mixin',
+            'modifier', ${modifier("baseClass")},
+            'label', [baseClass].[DisplayLabel],
+            'description', [baseClass].[Description],
+            'appliesTo', (
+              SELECT IIF(instr([atCTE].[AppliesTo], ':') > 1, ec_classname(ec_classId([atCTE].[AppliesTo]), 's.c'), CONCAT([atCTE].[AppliesToSchema], '.', [atCTE].[AppliesTo]))
+              FROM [AppliesToCTE] [atCTE]
+              WHERE [atCTE].[AppliesToId] = [baseClass].[ECInstanceId]
+            ),
+            'baseClasses', (
+              SELECT
+                json_group_array(json(json_object(
+                  'schema', ec_classname([mixinBaseClass].[ECInstanceId], 's'),
+                  'name', [mixinBaseClass].[Name],
+                  'schemaItemType', 'Mixin',
+                  'modifier', ${modifier("mixinBaseClass")},
+                  'label', [mixinBaseClass].[DisplayLabel],
+                  'description', [mixinBaseClass].[Description],
+                  'appliesTo', (
+                    SELECT IIF(instr([atCTE].[AppliesTo], ':') > 1, ec_classname(ec_classId([atCTE].[AppliesTo]), 's.c'), CONCAT([atCTE].[AppliesToSchema], '.', [atCTE].[AppliesTo]))
+                    FROM [AppliesToCTE] [atCTE]
+                    WHERE [atCTE].[AppliesToId] = [mixinBaseClass].[ECInstanceId]
+                  )
+                )))
+              FROM
+                [meta].[ECClassDef] [mixinBaseClass]
+              INNER JOIN [meta].[ClassHasAllBaseClasses] [mixinBaseClassMap]
+                ON [mixinBaseClassMap].[TargetECInstanceId] = [mixinBaseClass].[ECInstanceId]
+              WHERE [mixinBaseClassMap].[SourceECInstanceId] = [baseClass].[ECInstanceId]
+            )
+          )))
+        FROM
+          [meta].[ECClassDef] [baseClass]
+        INNER JOIN [meta].[ClassHasBaseClasses] [baseClassMap]
+          ON [baseClassMap].[TargetECInstanceId] = [baseclass].[ECInstanceId]
+        WHERE [baseClassMap].[SourceECInstanceId] = [class].[ECInstanceId]
+          AND EXISTS(SELECT 1 FROM [meta].[ClassCustomAttribute] [ca] WHERE [baseClass].[ECInstanceId] = [ca].[Class].[Id]
+            AND [ca].[CustomAttributeClass].[Id] Is ([CoreCA].[IsMixin]))
+          )
+    ) AS [item]
+  FROM [meta].[ECClassDef] [class]
+  WHERE [class].[Type] = 0
+    AND NOT EXISTS(SELECT 1 FROM [meta].[ClassCustomAttribute] [ca] WHERE [class].[ECInstanceId] = [ca].[Class].[Id]
+      AND [ca].[CustomAttributeClass].[Id] Is ([CoreCA].[IsMixin]))
+`;
+const mixinQuery = `
+  SELECT
+    [Schema].[Id] AS [SchemaId],
+    json_object(
+      'name', [class].[Name],
+      'schemaItemType', 'Mixin',
+      'modifier', ${modifier("class")},
+      'label', [class].[DisplayLabel],
+      'description', [class].[Description],
+      'appliesTo', (
+        SELECT IIF(instr([atCTE].[AppliesTo], ':') > 1, ec_classname(ec_classId([atCTE].[AppliesTo]), 's.c'), CONCAT([atCTE].[AppliesToSchema], '.', [atCTE].[AppliesTo]))
+        FROM [AppliesToCTE] [atCTE]
+        WHERE [atCTE].[AppliesToId] = [class].[ECInstanceId]
+      ),
+      'baseClasses', (
+        SELECT
+          json_group_array(json(json_object(
+            'schema', ec_classname([baseClass].[ECInstanceId], 's'),
+            'name', [baseClass].[Name],
+            'schemaItemType', 'Mixin',
+            'modifier', ${modifier("baseClass")},
+            'label', [baseClass].[DisplayLabel],
+            'description', [baseClass].[Description],
+            'appliesTo', (
+              SELECT IIF(instr([atCTE].[AppliesTo], ':') > 1, ec_classname(ec_classId([atCTE].[AppliesTo]), 's.c'), CONCAT([atCTE].[AppliesToSchema], '.', [atCTE].[AppliesTo]))
+              FROM [AppliesToCTE] [atCTE]
+              WHERE [atCTE].[AppliesToId] = [baseClass].[ECInstanceId]
+            )
+          )))
+        FROM
+          [meta].[ECClassDef] [baseClass]
+        INNER JOIN [meta].[ClassHasAllBaseClasses] [baseClassMap]
+          ON [baseClassMap].[TargetECInstanceId] = [baseclass].[ECInstanceId]
+        WHERE [baseClassMap].[SourceECInstanceId] = [class].[ECInstanceId]
+      )
+    ) AS [item]
+    FROM [meta].[ECClassDef] [class]
+    WHERE [class].[Type] = 0 AND EXISTS (SELECT 1 FROM [meta].[ClassCustomAttribute] [ca] WHERE [class].[ECInstanceId] = [ca].[Class].[Id]
+      AND [ca].[CustomAttributeClass].[Id] Is ([CoreCA].[IsMixin]))
+`;
+const withSchemaItems = `
+SchemaItems AS (
+  ${customAttributeQuery}
+  UNION ALL
+  ${structQuery}
+  UNION ALL
+  ${relationshipQuery}
+  UNION ALL
+  ${entityQuery}
+  UNION ALL
+  ${mixinQuery}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.enumeration()}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.kindOfQuantity()}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.propertyCategory()}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.unit()}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.invertedUnit()}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.constant()}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.phenomenon()}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.unitSystem()}
+  UNION ALL
+  ${_SchemaItemQueries__WEBPACK_IMPORTED_MODULE_0__.SchemaItemQueries.format()}
+  )
+`;
+const schemaStubQuery = `
+  WITH
+    ${withSchemaReferences},
+    ${withAppliesTo},
+    ${withSchemaItems}
+  SELECT
+    [Name] as [name],
+    CONCAT('',[VersionMajor],'.',[VersionWrite],'.',[VersionMinor]) AS [version],
+    [Alias] as [alias],
+    [DisplayLabel] as [displayLabel],
+    [Description] as [description],
+    (
+      SELECT
+        json_group_array([schemaReferences].[fullName])
+      FROM
+        [SchemaReferences] [schemaReferences]
+      WHERE
+        [schemaReferences].[SchemaId] = [schemaDef].[ECInstanceId]
+    ) AS [references],
+    (
+      SELECT
+        json_group_array(json([items].[item]))
+      FROM
+        [SchemaItems] [items]
+      WHERE
+        [items].[SchemaId] = [schemaDef].[ECInstanceId]
+    ) AS [items]
+  FROM
+    [meta].[ECSchemaDef] [schemaDef]
+  WHERE [Name] = :schemaName
+`;
+const schemaInfoQuery = `
+  WITH
+    ${withSchemaReferences}
+  SELECT
+    [Name] as [name],
+    CONCAT('',[VersionMajor],'.',[VersionWrite],'.',[VersionMinor]) AS [version],
+    [Alias] as [alias],
+    (
+      SELECT
+        json_group_array([schemaReferences].[fullName])
+      FROM
+        [SchemaReferences] [schemaReferences]
+      WHERE
+        [schemaReferences].[SchemaId] = [schemaDef].[ECInstanceId]
+    ) AS [references]
+  FROM
+    [meta].[ECSchemaDef] [schemaDef]
+`;
+/**
+ * Partial Schema queries.
+ * @internal
+ */
+const ecsqlQueries = {
+    schemaStubQuery,
+    schemaInfoQuery,
+};
+
+
 /***/ }),
 
 /***/ "../../core/ecschema-metadata/lib/esm/Interfaces.js":
@@ -98453,6 +100925,7 @@ class Schema {
     _customAttributes;
     _originalECSpecMajorVersion;
     _originalECSpecMinorVersion;
+    _loadingController;
     /** @internal */
     constructor(context, nameOrKey, alias, readVer, writeVer, minorVer) {
         this._schemaKey = (typeof (nameOrKey) === "string") ? new _SchemaKey__WEBPACK_IMPORTED_MODULE_6__.SchemaKey(nameOrKey, new _SchemaKey__WEBPACK_IMPORTED_MODULE_6__.ECVersion(readVer, writeVer, minorVer)) : nameOrKey;
@@ -98518,6 +100991,14 @@ class Schema {
     get schema() { return this; }
     /** Returns the schema context this schema is within. */
     get context() { return this._context; }
+    /**
+     * Returns the SchemaLoadingController for this Schema. This would only be set if the schema is
+     * loaded incrementally.
+     * @internal
+     */
+    get loadingController() {
+        return this._loadingController;
+    }
     /**
      * Returns a SchemaItemKey given the item name and the schema it belongs to
      * @param fullName fully qualified name {Schema name}.{Item Name}
@@ -99143,6 +101624,10 @@ class Schema {
         }
         this._alias = alias;
     }
+    /** @internal */
+    setLoadingController(controller) {
+        this._loadingController = controller;
+    }
 }
 /**
  * Hackish approach that works like a "friend class" so we can access protected members without making them public.
@@ -99196,6 +101681,7 @@ class SchemaItem {
     _key;
     _description;
     _label;
+    _loadingController;
     /** @internal */
     constructor(schema, name) {
         this._key = new _SchemaKey__WEBPACK_IMPORTED_MODULE_3__.SchemaItemKey(name, schema.schemaKey);
@@ -99206,6 +101692,14 @@ class SchemaItem {
     get key() { return this._key; }
     get label() { return this._label; }
     get description() { return this._description; }
+    /**
+     * Returns the SchemaLoadingController for this Schema. This would only be set if the schema is
+     * loaded incrementally.
+     * @internal
+     */
+    get loadingController() {
+        return this._loadingController;
+    }
     // Proposal: Create protected setter methods for description and label? For UnitSystems as an example, where using createFromProps isn't that necessary and can just use basic create().
     /**
      * Save this SchemaItem's properties to an object for serializing to JSON.
@@ -99311,6 +101805,10 @@ class SchemaItem {
     setDescription(description) {
         this._description = description;
     }
+    /** @internal */
+    setLoadingController(controller) {
+        this._loadingController = controller;
+    }
 }
 
 
@@ -101465,6 +103963,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   ECSchemaError: () => (/* reexport safe */ _Exception__WEBPACK_IMPORTED_MODULE_9__.ECSchemaError),
 /* harmony export */   ECSchemaNamespaceUris: () => (/* reexport safe */ _Constants__WEBPACK_IMPORTED_MODULE_0__.ECSchemaNamespaceUris),
 /* harmony export */   ECSchemaStatus: () => (/* reexport safe */ _Exception__WEBPACK_IMPORTED_MODULE_9__.ECSchemaStatus),
+/* harmony export */   ECSqlSchemaLocater: () => (/* reexport safe */ _IncrementalLoading_ECSqlSchemaLocater__WEBPACK_IMPORTED_MODULE_39__.ECSqlSchemaLocater),
 /* harmony export */   ECStringConstants: () => (/* reexport safe */ _Constants__WEBPACK_IMPORTED_MODULE_0__.ECStringConstants),
 /* harmony export */   ECVersion: () => (/* reexport safe */ _SchemaKey__WEBPACK_IMPORTED_MODULE_31__.ECVersion),
 /* harmony export */   EntityClass: () => (/* reexport safe */ _Metadata_EntityClass__WEBPACK_IMPORTED_MODULE_14__.EntityClass),
@@ -101472,6 +103971,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   EnumerationArrayProperty: () => (/* reexport safe */ _Metadata_Property__WEBPACK_IMPORTED_MODULE_22__.EnumerationArrayProperty),
 /* harmony export */   EnumerationProperty: () => (/* reexport safe */ _Metadata_Property__WEBPACK_IMPORTED_MODULE_22__.EnumerationProperty),
 /* harmony export */   Format: () => (/* reexport safe */ _Metadata_Format__WEBPACK_IMPORTED_MODULE_16__.Format),
+/* harmony export */   IncrementalSchemaLocater: () => (/* reexport safe */ _IncrementalLoading_IncrementalSchemaLocater__WEBPACK_IMPORTED_MODULE_40__.IncrementalSchemaLocater),
 /* harmony export */   InvertedUnit: () => (/* reexport safe */ _Metadata_InvertedUnit__WEBPACK_IMPORTED_MODULE_17__.InvertedUnit),
 /* harmony export */   KindOfQuantity: () => (/* reexport safe */ _Metadata_KindOfQuantity__WEBPACK_IMPORTED_MODULE_18__.KindOfQuantity),
 /* harmony export */   Mixin: () => (/* reexport safe */ _Metadata_Mixin__WEBPACK_IMPORTED_MODULE_19__.Mixin),
@@ -101494,7 +103994,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   SchemaCache: () => (/* reexport safe */ _Context__WEBPACK_IMPORTED_MODULE_1__.SchemaCache),
 /* harmony export */   SchemaContext: () => (/* reexport safe */ _Context__WEBPACK_IMPORTED_MODULE_1__.SchemaContext),
 /* harmony export */   SchemaFormatsProvider: () => (/* reexport safe */ _SchemaFormatsProvider__WEBPACK_IMPORTED_MODULE_38__.SchemaFormatsProvider),
-/* harmony export */   SchemaGraph: () => (/* reexport safe */ _utils_SchemaGraph__WEBPACK_IMPORTED_MODULE_39__.SchemaGraph),
+/* harmony export */   SchemaGraph: () => (/* reexport safe */ _utils_SchemaGraph__WEBPACK_IMPORTED_MODULE_41__.SchemaGraph),
 /* harmony export */   SchemaGraphUtil: () => (/* reexport safe */ _Deserialization_SchemaGraphUtil__WEBPACK_IMPORTED_MODULE_3__.SchemaGraphUtil),
 /* harmony export */   SchemaItem: () => (/* reexport safe */ _Metadata_SchemaItem__WEBPACK_IMPORTED_MODULE_26__.SchemaItem),
 /* harmony export */   SchemaItemKey: () => (/* reexport safe */ _SchemaKey__WEBPACK_IMPORTED_MODULE_31__.SchemaItemKey),
@@ -101575,7 +104075,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _Validation_SchemaWalker__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(/*! ./Validation/SchemaWalker */ "../../core/ecschema-metadata/lib/esm/Validation/SchemaWalker.js");
 /* harmony import */ var _SchemaPartVisitorDelegate__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(/*! ./SchemaPartVisitorDelegate */ "../../core/ecschema-metadata/lib/esm/SchemaPartVisitorDelegate.js");
 /* harmony import */ var _SchemaFormatsProvider__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(/*! ./SchemaFormatsProvider */ "../../core/ecschema-metadata/lib/esm/SchemaFormatsProvider.js");
-/* harmony import */ var _utils_SchemaGraph__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(/*! ./utils/SchemaGraph */ "../../core/ecschema-metadata/lib/esm/utils/SchemaGraph.js");
+/* harmony import */ var _IncrementalLoading_ECSqlSchemaLocater__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(/*! ./IncrementalLoading/ECSqlSchemaLocater */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/ECSqlSchemaLocater.js");
+/* harmony import */ var _IncrementalLoading_IncrementalSchemaLocater__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(/*! ./IncrementalLoading/IncrementalSchemaLocater */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/IncrementalSchemaLocater.js");
+/* harmony import */ var _utils_SchemaGraph__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__(/*! ./utils/SchemaGraph */ "../../core/ecschema-metadata/lib/esm/utils/SchemaGraph.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -101617,6 +104119,8 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
+
 
 
 
@@ -101759,6 +104263,81 @@ class SchemaGraph {
 }
 
 
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/utils/SchemaLoadingController.js":
+/*!*****************************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/utils/SchemaLoadingController.js ***!
+  \*****************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   SchemaLoadingController: () => (/* binding */ SchemaLoadingController)
+/* harmony export */ });
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Assists in tracking the loading progress of Schemas and SchemaItems. An instance of this
+ * class is set in Schema and SchemaItem instances.
+ * @internal
+ */
+class SchemaLoadingController {
+    _complete;
+    _inProgress;
+    _promise;
+    /**
+     * Indicates of the Schema or SchemaItem has been fully loaded.
+     */
+    get isComplete() {
+        return this._complete;
+    }
+    /**
+     * Marks that a Schema or SchemaItem has been fully loaded.
+     */
+    set isComplete(value) {
+        this._complete = value;
+    }
+    /**
+     * Indicates that the loading of a Schema or SchemaItem is still in progress
+     */
+    get inProgress() {
+        return this._inProgress;
+    }
+    /**
+     * Initializes a new SchemaLoadingController instance.
+     */
+    constructor() {
+        this._complete = false;
+        this._inProgress = false;
+    }
+    /**
+     * Call this method when starting to load a Schema or SchemaItem
+     * @param promise The promise used to update the controller state when the promise is resolved.
+     */
+    start(promise) {
+        this._inProgress = true;
+        void promise.then(() => {
+            this._complete = true;
+            this._inProgress = false;
+        });
+        this._promise = promise;
+    }
+    /**
+     * Waits on the Promise given in SchemaLoadingController.start().
+     * @returns A Promised that can be awaited while the Schema or SchemaItem is being loaded.
+     */
+    async wait() {
+        if (!this._promise)
+            throw new Error("LoadingController 'start' must be called before 'wait'");
+        return this._promise;
+    }
+}
+
+
 /***/ }),
 
 /***/ "../../core/ecschema-rpc/common/lib/esm/ECSchemaRpcInterface.js":
@@ -101907,6 +104486,74 @@ class ECSchemaRpcLocater {
 }
 
 
+/***/ }),
+
+/***/ "../../core/ecschema-rpc/common/lib/esm/RpcIncrementalSchemaLocater.js":
+/*!*****************************************************************************!*\
+  !*** ../../core/ecschema-rpc/common/lib/esm/RpcIncrementalSchemaLocater.js ***!
+  \*****************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   RpcIncrementalSchemaLocater: () => (/* binding */ RpcIncrementalSchemaLocater)
+/* harmony export */ });
+/* harmony import */ var _itwin_core_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @itwin/core-common */ "../../core/common/lib/esm/core-common.js");
+/* harmony import */ var _itwin_ecschema_metadata__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @itwin/ecschema-metadata */ "../../core/ecschema-metadata/lib/esm/ecschema-metadata.js");
+/* harmony import */ var _ECSchemaRpcInterface__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ECSchemaRpcInterface */ "../../core/ecschema-rpc/common/lib/esm/ECSchemaRpcInterface.js");
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+
+
+/**
+ * A [[ECSqlSchemaLocater]]($ecschema-metadata) implementation that uses the ECSchema RPC interfaces to load schemas incrementally.
+ * @beta
+ */
+class RpcIncrementalSchemaLocater extends _itwin_ecschema_metadata__WEBPACK_IMPORTED_MODULE_1__.ECSqlSchemaLocater {
+    _iModelProps;
+    /**
+     * Initializes a new instance of the RpcIncrementalSchemaLocater class.
+     */
+    constructor(iModelProps, options) {
+        super(options);
+        this._iModelProps = iModelProps;
+    }
+    /**
+     * Executes the given ECSql query and returns the resulting rows.
+     * @param query The ECSql query to execute.
+     * @param options Optional arguments to control the query result.
+     * @returns A promise that resolves to the resulting rows.
+     */
+    async executeQuery(query, options) {
+        const ecSqlQueryClient = _itwin_core_common__WEBPACK_IMPORTED_MODULE_0__.IModelReadRpcInterface.getClient();
+        const queryExecutor = {
+            execute: async (request) => ecSqlQueryClient.queryRows(this._iModelProps, request),
+        };
+        const queryOptions = {
+            limit: { count: options?.limit },
+            rowFormat: _itwin_core_common__WEBPACK_IMPORTED_MODULE_0__.QueryRowFormat.UseECSqlPropertyNames,
+        };
+        const queryParameters = options && options.parameters ? _itwin_core_common__WEBPACK_IMPORTED_MODULE_0__.QueryBinder.from(options.parameters) : undefined;
+        const queryReader = new _itwin_core_common__WEBPACK_IMPORTED_MODULE_0__.ECSqlReader(queryExecutor, query, queryParameters, queryOptions);
+        return queryReader.toArray();
+    }
+    /**
+     * Gets the [[SchemaProps]]($ecschema-metadata) for the given [[SchemaKey]]($ecschema-metadata).
+     * This is the full schema json with all elements that are defined in the schema.
+     * @param schemaKey The schema key of the schema to be resolved.
+     */
+    async getSchemaProps(schemaKey) {
+        const rpcSchemaClient = _ECSchemaRpcInterface__WEBPACK_IMPORTED_MODULE_2__.ECSchemaRpcInterface.getClient();
+        return rpcSchemaClient.getSchemaJSON(this._iModelProps, schemaKey.name);
+    }
+    ;
+}
+
+
 /***/ }),
 
 /***/ "../../core/ecschema-rpc/common/lib/esm/ecschema-rpc-interface.js":
@@ -101919,10 +104566,12 @@ class ECSchemaRpcLocater {
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   ECSchemaRpcInterface: () => (/* reexport safe */ _ECSchemaRpcInterface__WEBPACK_IMPORTED_MODULE_0__.ECSchemaRpcInterface),
-/* harmony export */   ECSchemaRpcLocater: () => (/* reexport safe */ _ECSchemaRpcLocater__WEBPACK_IMPORTED_MODULE_1__.ECSchemaRpcLocater)
+/* harmony export */   ECSchemaRpcLocater: () => (/* reexport safe */ _ECSchemaRpcLocater__WEBPACK_IMPORTED_MODULE_1__.ECSchemaRpcLocater),
+/* harmony export */   RpcIncrementalSchemaLocater: () => (/* reexport safe */ _RpcIncrementalSchemaLocater__WEBPACK_IMPORTED_MODULE_2__.RpcIncrementalSchemaLocater)
 /* harmony export */ });
 /* harmony import */ var _ECSchemaRpcInterface__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ECSchemaRpcInterface */ "../../core/ecschema-rpc/common/lib/esm/ECSchemaRpcInterface.js");
 /* harmony import */ var _ECSchemaRpcLocater__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ECSchemaRpcLocater */ "../../core/ecschema-rpc/common/lib/esm/ECSchemaRpcLocater.js");
+/* harmony import */ var _RpcIncrementalSchemaLocater__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./RpcIncrementalSchemaLocater */ "../../core/ecschema-rpc/common/lib/esm/RpcIncrementalSchemaLocater.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -101931,6 +104580,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 /***/ }),
 
 /***/ "../../core/frontend/lib/esm/AccuDraw.js":
@@ -328419,7 +331069,7 @@ class QuantityConstants {
             return QuantityConstants._LOCALE_THOUSAND_SEPARATOR;
         QuantityConstants._LOCALE_THOUSAND_SEPARATOR = ",";
         const matches = (12345.6789).toLocaleString().match(/12(.*)345/);
-        if (matches && matches.length > 0)
+        if (matches && matches.length > 1 && matches[1] !== "")
             QuantityConstants._LOCALE_THOUSAND_SEPARATOR = matches[1];
         return QuantityConstants._LOCALE_THOUSAND_SEPARATOR;
     }
@@ -332205,7 +334855,7 @@ class TestContext {
         this.initializeRpcInterfaces({ title: this.settings.Backend.name, version: this.settings.Backend.version });
         const iModelClient = new imodels_client_management_1.IModelsClient({ api: { baseUrl: `https://${process.env.IMJS_URL_PREFIX ?? ""}api.bentley.com/imodels` } });
         await core_frontend_1.NoRenderApp.startup({
-            applicationVersion: "5.1.0-dev.58",
+            applicationVersion: "5.1.0-dev.60",
             applicationId: this.settings.gprid,
             authorizationClient: new frontend_1.TestFrontendAuthorizationClient(this.serviceAuthToken),
             hubAccess: new imodels_access_frontend_1.FrontendIModelsAccess(iModelClient),
@@ -357292,7 +359942,7 @@ var loadLanguages = instance.loadLanguages;
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.1.0-dev.58","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs && npm run -s build:esm && npm run -s webpackWorkers && npm run -s copy:workers","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2022 --outDir lib/esm","clean":"rimraf -g lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","copy:workers":"cpx \\"./lib/workers/webpack/parse-imdl-worker.js\\" ./lib/public/scripts","docs":"betools docs --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-inline-config -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run webpackTestWorker && vitest --run","cover":"npm run webpackTestWorker && vitest --run","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2 && npm run -s webpackTestWorker","webpackTestWorker":"webpack --config ./src/test/worker/webpack.config.js 1>&2 && cpx \\"./lib/test/test-worker.js\\" ./lib/test","webpackWorkers":"webpack --config ./src/workers/ImdlParser/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core.git","directory":"core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*","@itwin/eslint-plugin":"5.0.0-dev.1","@types/chai-as-promised":"^7","@types/sinon":"^17.0.2","@vitest/browser":"^3.0.6","@vitest/coverage-v8":"^3.0.6","cpx2":"^8.0.0","eslint":"^9.13.0","glob":"^10.3.12","playwright":"~1.47.1","rimraf":"^6.0.1","sinon":"^17.0.2","source-map-loader":"^5.0.0","typescript":"~5.6.2","typemoq":"^2.1.0","vitest":"^3.0.6","vite-multiple-assets":"^1.3.1","vite-plugin-static-copy":"2.2.0","webpack":"^5.97.1"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/cloud-agnostic-core":"^2.2.4","@itwin/object-storage-core":"^2.3.0","@itwin/core-i18n":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.1.0-dev.60","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs && npm run -s build:esm && npm run -s webpackWorkers && npm run -s copy:workers","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2022 --outDir lib/esm","clean":"rimraf -g lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","copy:workers":"cpx \\"./lib/workers/webpack/parse-imdl-worker.js\\" ./lib/public/scripts","docs":"betools docs --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-inline-config -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run webpackTestWorker && vitest --run","cover":"npm run webpackTestWorker && vitest --run","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2 && npm run -s webpackTestWorker","webpackTestWorker":"webpack --config ./src/test/worker/webpack.config.js 1>&2 && cpx \\"./lib/test/test-worker.js\\" ./lib/test","webpackWorkers":"webpack --config ./src/workers/ImdlParser/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core.git","directory":"core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*","@itwin/eslint-plugin":"5.0.0-dev.1","@types/chai-as-promised":"^7","@types/sinon":"^17.0.2","@vitest/browser":"^3.0.6","@vitest/coverage-v8":"^3.0.6","cpx2":"^8.0.0","eslint":"^9.13.0","glob":"^10.3.12","playwright":"~1.47.1","rimraf":"^6.0.1","sinon":"^17.0.2","source-map-loader":"^5.0.0","typescript":"~5.6.2","typemoq":"^2.1.0","vitest":"^3.0.6","vite-multiple-assets":"^1.3.1","vite-plugin-static-copy":"2.2.0","webpack":"^5.97.1"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/cloud-agnostic-core":"^2.2.4","@itwin/object-storage-core":"^2.3.0","@itwin/core-i18n":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"}}');
 
 /***/ }),