@microsoft/typespec-msgraph 0.0.1-Preview.2 → 0.0.1-Preview.21

package/dist/src/utils.js

@@ -1,5 +1,18 @@
-import { getNamespaceFullName, isArrayModelType, } from "@typespec/compiler";
-import { getEntity, isEntity } from "./decorators/index.js";
+import { getLocationContext, getNamespaceFullName, isArrayModelType, walkPropertiesInherited, } from "@typespec/compiler";
+import { getEntity, getExpand, getFilter, getGraphRoutePaths, getPublicNamespaceName, getWorkloadNamespaceName, hasPublicNamespace, hasWorkloadNamespace, isComplex, isContains, isDelta, isEntity, isExpand, isFilter, isPartial, isReferences } from "./decorators/index.js";
+import { getOperationVerb } from "@typespec/http";
+import { usedLibraryTypesKey } from "./entities/namespace.js";
+// schema namespace is workloadNamespace if its defined or publicNamespace if its defined
+export function hasSchemaNamespace(program, namespace) {
+    return hasWorkloadNamespace(program, namespace) || hasPublicNamespace(program, namespace);
+}
+// schema namespace is workloadNamespace if its defined, publicNamespace if its defined or the defined namespace name
+export function getSchemaNamespaceName(program, namespace) {
+    if (hasWorkloadNamespace(program, namespace)) {
+        return getWorkloadNamespaceName(program, namespace);
+    }
+    return getPublicNamespaceName(program, namespace);
+}
 export function getNameForType(program, type) {
     switch (type.kind) {
         case "Union":
@@ -25,6 +38,9 @@ export function getNameForType(program, type) {
 export function getNameForModelType(program, type) {
     switch (type.name) {
         case "string":
+        case "url":
+        case "graphUrl":
+        case "webUrl":
             return "Edm.String";
         case "bytes":
             return "Collection(Edm.Byte)";
@@ -46,12 +62,20 @@ export function getNameForModelType(program, type) {
             return "Edm.TimeOfDay";
         case "zonedDateTime":
             return "Edm.DateTimeOffset";
+        case "offsetDateTime":
+            return "Edm.DateTimeOffset";
+        case "utcDateTime":
+            return "Edm.DateTimeOffset";
         case "duration":
             return "Edm.Duration";
         case "boolean":
             return "Edm.Boolean";
         case "stream":
             return "Edm.Stream";
+        case "guid":
+            return "Edm.Guid";
+        case "unknown":
+            return "Edm.Untyped";
         default:
             break;
     }
@@ -60,21 +84,94 @@ export function getNameForModelType(program, type) {
     }
     return `Collection(${getPropertyTypeName(program, type.indexer.value)})`;
 }
+export function getCSDLPrimitiveType(typespecType) {
+    switch (typespecType) {
+        case "string":
+            return "String";
+        case "int8":
+            return "Byte";
+        case "int16":
+            return "Int16";
+        case "int32":
+            return "Int32";
+        case "int64":
+            return "Int64";
+        case "integer":
+            return "Int64";
+        case "float32":
+            return "Single";
+        case "float64":
+            return "Double";
+        case "decimal":
+            return "Decimal";
+        case "guid":
+            return "Guid";
+        case "plainDate":
+            return "Date";
+        case "plainTime":
+            return "TimeOfDay";
+        case "zonedDateTime":
+            return "DateTimeOffset";
+        case "duration":
+            return "Duration";
+        case "boolean":
+            return "Bool";
+        case "stream":
+            return "Stream";
+        default:
+            return typespecType;
+    }
+}
+export function isDictionaryType(program, type) {
+    var _a;
+    if (type.kind === "Model" && getLocationContext(program, type).type === "project") {
+        const indexer = (_a = type.indexer) === null || _a === void 0 ? void 0 : _a.value;
+        if (indexer) {
+            return true;
+        }
+        if (isComplex(program, type) && type.name === "Dictionary") {
+            return true;
+        }
+    }
+    return false;
+}
+export function generateDictionaryBaseType(program, model) {
+    if (getLocationContext(program, model).type === "library") {
+        return undefined;
+    }
+    if (isDictionaryType(program, model)) {
+        return "microsoft.graph.Dictionary";
+    }
+    return undefined;
+}
 export function getIdForType(program, type) {
     switch (type.kind) {
         case "Namespace":
-            return getNamespaceFullName(type);
+            if (hasWorkloadNamespace(program, type)) {
+                return getWorkloadNamespaceName(program, type);
+            }
+            else if (hasPublicNamespace(program, type)) {
+                return getPublicNamespaceName(program, type);
+            }
+            else {
+                return getNamespaceFullName(type);
+            }
         case "Model":
         case "Enum":
         case "Operation":
         case "Interface":
-            return `${getNamespaceFullName(type.namespace)}.${type.name}`;
+            return `${getIdForType(program, type.namespace)}.${type.name}`;
         case "String":
         case "Number":
         case "Boolean":
             return `${type.value}`;
         case "Union":
             return getIdForUnion(program, type);
+        case "Scalar":
+        case "Intrinsic":
+            return getNameForModelType(program, type);
+        case "EnumMember":
+            return `${type.name}`;
         default:
             return type.kind;
     }
@@ -87,37 +184,110 @@ export function getNavigationTypeId(program, getOperation) {
     }
     return getIdForType(program, returnType.templateArguments[0]);
 }
+export function getInterfacesOfKinds(program, navigationSources, kinds) {
+    const interfaces = new Map();
+    navigationSources.forEach((theInterface) => {
+        if (!getSourceInterfaces(theInterface).some((s) => kinds.includes(s.name))) {
+            // if source interfaces DO NOT have the kinds.
+            return;
+        }
+        const navigationSourceType = getInterfaceNavigationSourceType(program, theInterface);
+        if (navigationSourceType && isTypeDefinedInExternalLibrary(program, navigationSourceType)) {
+            program.stateSet(usedLibraryTypesKey).add(navigationSourceType);
+        }
+        const graphRoutePaths = getGraphRoutePaths(program, theInterface);
+        if (!graphRoutePaths || !graphRoutePaths.length) {
+            return;
+        }
+        graphRoutePaths.forEach((graphRoute) => {
+            // skip two-segment resources as they are collections
+            if (isRouteIndexOfACollection(theInterface, graphRoute)) {
+                return;
+            }
+            processGraphRoute(program, graphRoute, interfaces, theInterface);
+        });
+    });
+    return interfaces;
+}
+export function isRouteIndexOfACollection(theInterface, graphRoute) {
+    if (theInterface === undefined) {
+        return false;
+    }
+    const pathSegments = graphRoute.split("/");
+    const lastSegment = pathSegments[pathSegments.length - 1].replace(/\{[\w-]+\}/g, "");
+    if (lastSegment === "" && getSourceInterfaces(theInterface).some((s) => s.name === "Resource")) {
+        return true;
+    }
+    return false;
+}
+// Generate an interface for a resource that has a root path and an index like /users/{id}. Note that this is a collection.
+// Resources with two-segment paths like /users/{id} are essentially collections
+// This applies to deeply nested resources as well e.g. /cars/{carId}/wheels/{wheelId}
+export function getCollectionIndexInterfaces(program, navigationSources) {
+    const interfaces = new Map();
+    navigationSources.forEach((theInterface) => {
+        const graphRoutePaths = getGraphRoutePaths(program, theInterface);
+        if (!graphRoutePaths || !graphRoutePaths.length) {
+            return;
+        }
+        graphRoutePaths.forEach((graphRoute) => {
+            if (isRouteIndexOfACollection(theInterface, graphRoute)) {
+                processGraphRoute(program, graphRoute, interfaces, theInterface);
+            }
+        });
+    });
+    return interfaces;
+}
+function processGraphRoute(program, graphRoute, interfaces, theInterface) {
+    const path = removeRoutePathParams(graphRoute);
+    if (!path) {
+        return;
+    }
+    let operations = [...theInterface.operations.values()].map((operation) => ({ theOperation: operation, verb: getOperationVerb(program, operation), graphRoute: graphRoute }));
+    if (interfaces.has(path)) {
+        const existing = interfaces.get(path);
+        operations = [...operations, ...existing.operations];
+    }
+    interfaces.set(path, {
+        theInterface: theInterface,
+        operations: operations,
+        path: graphRoute
+    });
+}
 export function getPropertyTypeName(program, type) {
     var _a;
     if (type.kind === "Union") {
         const unionTypes = extractTypesFromUnion(type);
-        const nonNullTypes = unionTypes.filter((t) => !isNullType(program, t));
+        const nonNullTypes = unionTypes.filter((t) => !isNullType(t));
         if (!nonNullTypes.length) {
             return "undefined.";
         }
-        return getPropertyTypeName(program, nonNullTypes[0]);
+        return removeReferencePrefixFromType(getPropertyTypeName(program, nonNullTypes[0]));
     }
     if ((type.kind === "Model" || type.kind === "Scalar") && ((_a = type.namespace) === null || _a === void 0 ? void 0 : _a.name) === "TypeSpec") {
-        return getNameForType(program, type);
+        return removeReferencePrefixFromType(getNameForType(program, type));
     }
-    return getIdForType(program, type);
+    return removeReferencePrefixFromType(getIdForType(program, type));
+}
+export function removeReferencePrefixFromType(typeName) {
+    return typeName.replace(/^reference\./, "");
 }
 export function isTypeNullable(program, type) {
     if (type.kind !== "Union") {
         return false;
     }
     const unionTypes = extractTypesFromUnion(type);
-    return unionTypes.some((t) => isNullType(program, t));
+    return unionTypes.some((t) => isNullType(t));
 }
 function getIdForUnion(program, unionType) {
     const unionTypes = extractTypesFromUnion(unionType);
-    const nonNullTypes = unionTypes.filter((t) => !isNullType(program, t));
+    const nonNullTypes = unionTypes.filter((t) => !isNullType(t));
     if (!nonNullTypes.length) {
         return "undefined.";
     }
     return getIdForType(program, nonNullTypes[0]);
 }
-function isNullType(program, type) {
+export function isNullType(type) {
     return type.kind === "Intrinsic" && type.name === "null";
 }
 export function extractTypesFromUnion(type) {
@@ -130,6 +300,26 @@ export function getSingletonTypeId(program, singletonType, getOperation) {
     }
     return getOperation && getNavigationTypeId(program, getOperation);
 }
+/**
+ * Returns whether a type matches Graph's  definition of a collection
+ * @param program
+ * @param type
+ */
+export function isTypeCollection(Program, type) {
+    let modelTypes = [];
+    if (type.kind === "Union") {
+        const extracted = (extractTypesFromUnion(type).filter((t) => t.kind === "Model"));
+        modelTypes = modelTypes.concat(extracted);
+    }
+    else if (type.kind === "Model") {
+        modelTypes.push(type);
+    }
+    if (modelTypes.length === 0) {
+        return false;
+    }
+    return modelTypes.some((t) => t.kind === "Model" &&
+        (t.name === "Array" || t.name.includes("Collection")));
+}
 /**
  * Imported from typespec-azure
  * Returns the full namespace name for the given type, if available.
@@ -167,11 +357,24 @@ export function isExcludedCoreType(program, type) {
     // https://github.com/Azure/typespec-azure/issues/801#issuecomment-1194454247
     //
     const nsName = getNamespaceName(program, type);
-    const excludedNamespaces = ["TypeSpec", "TypeSpec"];
+    const excludedNamespaces = ["TypeSpec", "MsGraph"];
+    return excludedNamespaces.find((ns) => nsName.startsWith(ns)) !== undefined;
+}
+export function isExcludedLibraryType(program, type) {
+    const nsName = getNamespaceName(program, type);
+    const excludedNamespaces = ["TypeSpec", "MsGraph"];
     return excludedNamespaces.find((ns) => nsName.startsWith(ns)) !== undefined;
 }
 export function isNavigationProperty(program, property) {
     let propertyType = property.type;
+    if (propertyType.kind === "Union") {
+        const unionTypes = extractTypesFromUnion(propertyType);
+        const nonNullTypes = unionTypes.filter((t) => !isNullType(t));
+        if (!nonNullTypes.length) {
+            return false;
+        }
+        propertyType = nonNullTypes[0];
+    }
     if (propertyType.kind !== "Model") {
         return false;
     }
@@ -183,4 +386,495 @@ export function isNavigationProperty(program, property) {
     }
     return isEntity(program, propertyType);
 }
+export function isNavigationSource(theInterface) {
+    return findNavigationSource(theInterface) !== undefined;
+}
+export function isTopLevelNavigationSource(program, theInterface) {
+    return removeRoutePathParams(theInterface.path).split("/").length === 1;
+}
+// Get the type returned by all operations in an interface representing a navigation source.
+// This is the 'T' in Collection<T> and friends.
+export function getInterfaceNavigationSourceType(program, theInterface) {
+    var _a;
+    const navSource = findNavigationSource(theInterface);
+    if (navSource === undefined) {
+        return undefined;
+    }
+    else {
+        return (_a = navSource.templateMapper) === null || _a === void 0 ? void 0 : _a.args[0];
+    }
+}
+// Get the type returned by all operations in an interface representing a navigation source.
+export function getNavigationSourceType(program, operation) {
+    return getInterfaceNavigationSourceType(program, operation.interface);
+}
+function findNavigationSource(theInterface) {
+    for (const baseInterface of getSourceInterfaces(theInterface)) {
+        if (baseInterface.name === "Resource" || baseInterface.name === "Collection") {
+            return baseInterface;
+        }
+        else {
+            const baseBase = findNavigationSource(baseInterface);
+            if (baseBase !== undefined) {
+                return baseBase;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Removes route path params from a route path
+ *
+ * Examples:
+ *  - user/{id}/manager -> user/manager
+ *  - user/{id}/friends/{friendId}/hobbies -> user/friends/hobbies
+ *  - user/{user-id}/friends/{friend-id}/hobbies -> user/friends/hobbies
+ */
+export function removeRoutePathParams(routePath) {
+    return routePath.replace(/\/\{[\w-]+\}/g, "");
+}
+export function isSameNamespace(program, model, baseModel) {
+    if (!baseModel) {
+        return false;
+    }
+    return getNamespaceName(program, model) === getNamespaceName(program, baseModel);
+}
+export function isTypeDefinedInExternalLibrary(program, type) {
+    const locationContext = getLocationContext(program, type);
+    return locationContext.type === "library";
+}
+/**
+ * Recursively get all source interfaces of an interface
+ * @param theInterface
+ * @returns an array of all source interfaces
+ */
+export function getSourceInterfaces(theInterface) {
+    return [...theInterface.sourceInterfaces, ...[...theInterface.sourceInterfaces.values()].flatMap(getSourceInterfaces)];
+}
+export function getModelStructuralPropertyNames(program, model) {
+    return getModelPropertyNames(program, model, true);
+}
+export function getAllModelPropertyNames(program, model) {
+    return getModelPropertyNames(program, model, false);
+}
+function getModelPropertyNames(program, model, structuralPropertiesOnly) {
+    const propertyNames = getModelProperties(program, model, structuralPropertiesOnly).map(p => p.name.trim());
+    const propertiesOfTypeModel = getPropertiesOfTypeModel(program, model, structuralPropertiesOnly);
+    const nestedPropertyNames = getNestedPropertyNames(program, propertiesOfTypeModel, structuralPropertiesOnly);
+    return [...new Set([...propertyNames, ...nestedPropertyNames])].filter(p => p !== model.name);
+}
+function getModelProperties(program, model, structuralPropertiesOnly = false) {
+    const allProperties = walkPropertiesInherited(model);
+    // structural properties are the ones that are not navigation properties
+    if (structuralPropertiesOnly) {
+        return [...allProperties].filter((property) => !isContains(program, property) && !isReferences(program, property));
+    }
+    return [...allProperties];
+}
+function getPropertiesOfTypeModel(program, model, structuralPropertiesOnly = false) {
+    const properties = getModelProperties(program, model, structuralPropertiesOnly);
+    const propertiesOfTypeModel = [];
+    for (const property of properties) {
+        const type = getModelStructuredTypeFromProperty(property, structuralPropertiesOnly);
+        if (type) {
+            propertiesOfTypeModel.push(type);
+        }
+    }
+    return propertiesOfTypeModel;
+}
+function getModelStructuredTypeFromProperty(property, structuralPropertiesOnly = false) {
+    var _a;
+    const type = property.type;
+    if (type.kind === "Model") {
+        // Skip array-typed properties
+        if (type.name === "Array") {
+            if (!structuralPropertiesOnly) {
+                const indexer = (_a = type.indexer) === null || _a === void 0 ? void 0 : _a.value;
+                if (indexer && indexer.kind === "Model") {
+                    return {
+                        name: property.name,
+                        model: indexer
+                    };
+                }
+            }
+            else {
+                return null;
+            }
+        }
+        return {
+            name: property.name,
+            model: type
+        };
+    }
+    if (type.kind === "Union") {
+        const nonNullUnionTypes = extractTypesFromUnion(type).filter(t => !isNullType(t));
+        if (nonNullUnionTypes[0].kind === "Model") {
+            return {
+                name: property.name,
+                model: nonNullUnionTypes[0]
+            };
+        }
+    }
+    return null;
+}
+function getNestedPropertyNames(program, propertyModels, structuralPropertiesOnly = false, prefix = "") {
+    const names = [];
+    if (prefix && hasRepeatedItem(prefix)) {
+        return names;
+    }
+    for (const propertyModel of propertyModels) {
+        const propertyModelPrefix = prefix + propertyModel.name + "/";
+        const nestedPropertyModels = getNestedPropertyModels(program, propertyModel, structuralPropertiesOnly);
+        nestedPropertyModels.forEach(m => {
+            const name = propertyModelPrefix + m.name;
+            if (!hasRepeatedItem(name)) {
+                names.push(name);
+            }
+        });
+        names.push(...getNestedPropertyNames(program, nestedPropertyModels, structuralPropertiesOnly, propertyModelPrefix));
+    }
+    return names;
+}
+function getNestedPropertyModels(program, propertyModel, structuralPropertiesOnly = false) {
+    const propertyModels = [];
+    if (!propertyModel.model.properties) {
+        return propertyModels;
+    }
+    propertyModel.model.properties.forEach((property, name) => {
+        const model = getPropertyModel(program, property, structuralPropertiesOnly);
+        if (model !== null) {
+            propertyModels.push({ name: name, model: model });
+        }
+    });
+    return propertyModels;
+}
+function getPropertyModel(program, property, structuralPropertiesOnly = false) {
+    if (structuralPropertiesOnly && (isContains(program, property) || isReferences(program, property))) {
+        return null;
+    }
+    let type = property.type;
+    if (type.kind === "Union") {
+        const nonNullUnionTypes = extractTypesFromUnion(type).filter(t => !isNullType(t));
+        type = nonNullUnionTypes[0];
+    }
+    if (type.kind === "Model") {
+        if (type.name === "Array") {
+            if (type.indexer.value.kind !== "Model") {
+                return null;
+            }
+            type = type.indexer.value;
+        }
+    }
+    return type;
+}
+/**
+ * This function checks if a path is repeating.
+ * For example, if we have a tsp with this structure:
+    * @complex model inner {
+        innerName: string;
+        otherInnerName: string;
+        circularReferenceProp: outer;
+      }
+
+      @complex model outer {
+        inner: inner | null;
+      }
+
+  If our root (interface navigation type) is outer, some of the possible paths would be
+    - outer/inner/innerName
+    - outer/inner/otherInnerName
+  For circularReferenceProp property, we run the risk of having a path like the one below which would cause an infinite loop:
+  - outer/inner/circularReferenceProp/inner/circularReferenceProp
+ * @param slashSeparatedString
+ * @returns
+ */
+function hasRepeatedItem(slashSeparatedString) {
+    const items = slashSeparatedString.split('/');
+    const uniqueItems = new Set(items);
+    return items.length !== uniqueItems.size;
+}
+export function isInterfaceBindingTypeOwned(program, $interface) {
+    const interfaceBindingType = getInterfaceBindingType(program, $interface);
+    if (interfaceBindingType) {
+        if (isPartial(program, interfaceBindingType)) {
+            return false;
+        }
+        if (getLocationContext(program, interfaceBindingType).type === "library") {
+            return false;
+        }
+    }
+    return true;
+}
+function getInterfaceBindingType(program, $interface) {
+    const navigationSourceType = getInterfaceNavigationSourceType(program, $interface);
+    if (navigationSourceType) {
+        return getModelFromTemplateMapper(navigationSourceType);
+    }
+    return undefined;
+}
+export function getNestedComplexTypes(program, model, nestedModels = new Set()) {
+    nestedModels.add(model);
+    const modelProperties = model.properties;
+    if (modelProperties.size === 0) {
+        return nestedModels;
+    }
+    for (const property of modelProperties.values()) {
+        if (property.type.kind === "Model" && isComplex(program, property.type)) {
+            if (!nestedModels.has(property.type)) {
+                getNestedComplexTypes(program, property.type, nestedModels);
+            }
+        }
+        if (property.type.kind === "Union") {
+            const nonNullTypes = extractTypesFromUnion(property.type).filter((t) => !isNullType(t));
+            if (nonNullTypes.length > 0 && nonNullTypes[0].kind === "Model" && isComplex(program, nonNullTypes[0])) {
+                if (!nestedModels.has(nonNullTypes[0])) {
+                    getNestedComplexTypes(program, nonNullTypes[0], nestedModels);
+                }
+            }
+        }
+        if (property.type.kind === "Model" && isArrayModelType(program, property.type)) {
+            const indexer = property.type.indexer.value;
+            if (indexer.kind === "Model" && isComplex(program, indexer)) {
+                if (!nestedModels.has(indexer)) {
+                    getNestedComplexTypes(program, indexer, nestedModels);
+                }
+            }
+        }
+    }
+    return nestedModels;
+}
+export function generateDeltaPropertiesForNavigationProperties(program, navigationProperty) {
+    const navigationPropModelType = getModelType(navigationProperty.type);
+    if (navigationPropModelType) {
+        const interfacesTargetingParentModel = getInterfacesTargetingModel(program, navigationPropModelType);
+        for (const theInterface of interfacesTargetingParentModel) {
+            const graphRoutes = getGraphRoutePaths(program, theInterface);
+            if (graphRoutes) {
+                for (const graphRoute of graphRoutes) {
+                    const routeParts = graphRoute.split("/");
+                    const navPropAtEndOfRoute = routeParts[routeParts.length - 1];
+                    if (navPropAtEndOfRoute === navigationProperty.name) {
+                        return getDeltaProperties(program, theInterface);
+                    }
+                }
+            }
+        }
+    }
+    return undefined;
+}
+export function getInterfacesTargetingModel(program, type) {
+    const interfacesTargettingModel = [];
+    let model = getModelType(type);
+    if (model) {
+        const namespace = model.namespace;
+        const theInterfaces = namespace === null || namespace === void 0 ? void 0 : namespace.interfaces;
+        if (theInterfaces) {
+            for (const [_, theInterface] of theInterfaces.entries()) {
+                const navigationBindingType = getInterfaceNavigationSourceType(program, theInterface);
+                if (navigationBindingType && navigationBindingType.name === model.name) {
+                    interfacesTargettingModel.push(theInterface);
+                }
+            }
+        }
+    }
+    return interfacesTargettingModel;
+}
+// This function gets filterable and expandable properties
+export function getDeltaProperties(program, entity) {
+    const operations = entity.operations;
+    let hasDelta = false;
+    let filterProps;
+    let expandProps;
+    for (const [_, operation] of operations) {
+        // Get filterable and expandable properties as defined by @filter and @expand on the @delta operation
+        if (isDelta(program, operation)) {
+            hasDelta = true;
+            filterProps = getFilterableProperties(program, operation);
+            expandProps = getExpandableProperties(program, operation);
+            break;
+        }
+    }
+    // If the delta operation exists and the filter properties are not set, get the filter properties from the get operation
+    if (hasDelta && !filterProps) {
+        filterProps = [...getFilterablePropertiesFromGetOperation(program, operations)];
+    }
+    // If the delta operation exists and the expand properties are not set, get the expand properties from the get operation
+    if (hasDelta && !expandProps) {
+        expandProps = [...getExpandablePropertiesFromGetOperation(program, operations)];
+    }
+    if (hasDelta) {
+        return {
+            FilterProperties: filterProps,
+            ExpandProperties: expandProps,
+        };
+    }
+    return undefined;
+}
+function getFilterableProperties(program, operation) {
+    if (isFilter(program, operation)) {
+        const filterProps = getFilter(program, operation);
+        if (filterProps.includes("*")) {
+            // Return all structural properties (nested and inherited) as filterable
+            return getModelStructuralPropertyNamesFromOperation(program, operation);
+        }
+        return filterProps;
+    }
+    return undefined;
+}
+function getExpandableProperties(program, operation) {
+    if (isExpand(program, operation)) {
+        return getExpand(program, operation);
+    }
+    return undefined;
+}
+function getFilterablePropertiesFromGetOperation(program, operationsMap) {
+    const operations = [...operationsMap.values()];
+    if (operations.some(theOperation => isFilter(program, theOperation))) {
+        for (const operation of operations) {
+            if (operation.name === "get") {
+                if (isFilter(program, operation)) {
+                    const filterProps = getFilter(program, operation);
+                    if (filterProps.includes("*")) {
+                        // Return all structural properties (nested and inherited) as filterable
+                        return getModelStructuralPropertyNamesFromOperation(program, operation);
+                    }
+                    return filterProps;
+                }
+            }
+        }
+    }
+    return [];
+}
+function getModelStructuralPropertyNamesFromOperation(program, operation) {
+    const returnType = getNavigationSourceType(program, operation);
+    if (!returnType) {
+        return [];
+    }
+    const model = returnType.indexer ? returnType.indexer.value : returnType;
+    return getModelStructuralPropertyNames(program, model);
+}
+function getExpandablePropertiesFromGetOperation(program, operationsMap) {
+    const operations = [...operationsMap.values()];
+    if (operations.some(theOperation => isExpand(program, theOperation))) {
+        for (const operation of operations) {
+            if (operation.name === "get") {
+                if (isExpand(program, operation)) {
+                    return getExpand(program, operation);
+                }
+            }
+        }
+    }
+    return [];
+}
+export function isCollection(theInterfaces) {
+    return theInterfaces.some(theInterface => theInterface.name === "Collection");
+}
+export function isUnion(type) {
+    return type.kind === "Union";
+}
+export function filterMapByIdenticalValues(inputMap) {
+    var _a;
+    const resultMap = new Map();
+    const valueToKeys = new Map();
+    // Iterate over the input map
+    for (const [key, value] of inputMap.entries()) {
+        if (!valueToKeys.has(value)) {
+            valueToKeys.set(value, [key]);
+        }
+        else {
+            (_a = valueToKeys.get(value)) === null || _a === void 0 ? void 0 : _a.push(key);
+        }
+    }
+    // Add keys with identical values to the result map
+    for (const [value, keys] of valueToKeys.entries()) {
+        if (keys.length > 1) {
+            keys.forEach((key) => resultMap.set(key, value));
+        }
+    }
+    return resultMap;
+}
+// This gets nested navigation paths for all contained and non-contained models and root paths for primitive types. 
+export function getAllNestedNavigationPaths(program, model) {
+    const structuralProperties = getModelProperties(program, model, false).map(property => property.name);
+    const rootPropertyNames = structuralProperties.map(property => model.name + "/" + property);
+    let nestedPropertyNames = getAllModelPropertyNames(program, model);
+    nestedPropertyNames = nestedPropertyNames.map(propertyName => model.name + "/" + propertyName);
+    return [...new Set([...structuralProperties, ...nestedPropertyNames, ...rootPropertyNames])].filter(path => path !== model.name);
+}
+export function removeTrailingSlash(path) {
+    return path.replace(/\//, "");
+}
+/**
+ *
+ * @param obj1 Function that checks for equality of two objects
+ * @param obj2
+ * @returns
+ */
+export function isEqual(obj1, obj2) {
+    // Check if both are null or undefined
+    if (obj1 === obj2)
+        return true;
+    // Check if both are not objects or one is null
+    if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 === null || obj2 === null) {
+        return false;
+    }
+    // Check if they have the same number of properties
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    // Check if values are the same for each property
+    for (let key of keys1) {
+        if (!keys2.includes(key) || !isEqual(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function checkFunctionOverloadsWithReturnType(operation1, operation2) {
+    return functionOperationsAreOverloads(operation1, operation2, true);
+}
+export function checkFunctionOverloads(operation1, operation2) {
+    return functionOperationsAreOverloads(operation1, operation2);
+}
+function functionOperationsAreOverloads(operation1, operation2, checkReturnType = false) {
+    if (operation1.Name === operation2.Name && operation1.BindingTypeName === operation2.BindingTypeName) {
+        if (!checkReturnType || operation1.ReturnTypeName === operation2.ReturnTypeName) {
+            const properties1 = operation1.Properties.filter((property) => property.Name !== "bindingParameter").sort((a, b) => a.Name.localeCompare(b.Name));
+            const properties2 = operation2.Properties.filter((property) => property.Name !== "bindingParameter").sort((a, b) => a.Name.localeCompare(b.Name));
+            return isEqual(properties1, properties2);
+        }
+    }
+    return false;
+}
+export function getModelType(type) {
+    var _a;
+    if (type.kind === "Union") {
+        const nonNullTypes = extractTypesFromUnion(type).filter((t) => !isNullType(t));
+        if (nonNullTypes.length > 0 && nonNullTypes[0].kind === "Model") {
+            return nonNullTypes[0];
+        }
+    }
+    else if (type.kind === "Model" && type.name === "Array") {
+        const indexer = (_a = type.indexer) === null || _a === void 0 ? void 0 : _a.value;
+        if (indexer && indexer.kind === "Model") {
+            return indexer;
+        }
+    }
+    return type.kind === "Model" ? type : undefined;
+}
+/**
+ *
+ * @param model Handles case where model is wrapped in an EntityRef template
+ * @returns
+ */
+function getModelFromTemplateMapper(model) {
+    var _a;
+    const templateArguments = (_a = model.templateMapper) === null || _a === void 0 ? void 0 : _a.args;
+    if (templateArguments && templateArguments.length > 0) {
+        return getModelType(templateArguments[0]);
+    }
+    return getModelType(model);
+}
 //# sourceMappingURL=utils.js.map