@microsoft/typespec-msgraph 0.0.1-Preview.8 → 1.0.0-Preview.2

package/dist/src/lib.d.ts

@@ -1,59 +1,9 @@
-export declare const namespace = "TypeSpec.MsGraph";
-export declare const libDef: {
-    readonly name: "@microsoft/typespec-msgraph";
-    readonly diagnostics: {
-        readonly "decorator-missing-dependencies": {
-            readonly severity: "error";
-            readonly messages: {
-                readonly default: import("@typespec/compiler").CallableMessage<["decorator", "required", "location"]>;
-                readonly function: import("@typespec/compiler").CallableMessage<[]>;
-            };
-        };
-        readonly "element-missing-dependencies": {
-            readonly severity: "error";
-            readonly messages: {
-                readonly default: import("@typespec/compiler").CallableMessage<["element", "other", "location"]>;
-                readonly operation: import("@typespec/compiler").CallableMessage<[]>;
-                readonly collectionNavigationPropertiesNotNullable: "Collection-valued navigation properties cannot be nullable.";
-                readonly propertyRequiredForCreate: import("@typespec/compiler").CallableMessage<["property", "model"]>;
-            };
-        };
-        readonly "decorator-invalid-use": {
-            readonly severity: "error";
-            readonly messages: {
-                readonly default: import("@typespec/compiler").CallableMessage<["decorator", "other", "location"]>;
-                readonly alternateKey: import("@typespec/compiler").CallableMessage<[]>;
-                readonly disallowedTypeSpecDecorators: import("@typespec/compiler").CallableMessage<["decorator"]>;
-                readonly expandProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
-                readonly filterProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
-                readonly key: import("@typespec/compiler").CallableMessage<[]>;
-                readonly orderByProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
-                readonly required: import("@typespec/compiler").CallableMessage<["decorator", "parameters"]>;
-                readonly wrongType: import("@typespec/compiler").CallableMessage<["decorator", "target"]>;
-                readonly graphRoute: import("@typespec/compiler").CallableMessage<[]>;
-            };
-        };
-        readonly "singleton-invalid-name": {
-            readonly severity: "error";
-            readonly messages: {
-                readonly default: import("@typespec/compiler").CallableMessage<["value"]>;
-            };
-        };
-        readonly "extends-invalid-use": {
-            readonly severity: "error";
-            readonly messages: {
-                readonly default: import("@typespec/compiler").CallableMessage<["type", "type"]>;
-            };
-        };
-        readonly "use-evolvable-enum": {
-            readonly severity: "warning";
-            readonly messages: {
-                readonly default: import("@typespec/compiler").CallableMessage<["enum"]>;
-            };
-        };
-    };
-};
-export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
+export declare const namespace = "MsGraph";
+export interface MsGraphEmitterOptions {
+    filename?: string;
+}
+export declare const $flags: import("@typespec/compiler").PackageFlags;
+export declare const reportDiagnostic: <C extends "decorator-missing-dependencies" | "element-missing-dependencies" | "decorator-invalid-use" | "model-invalid-use" | "singleton-invalid-name" | "extends-invalid-use" | "type-invalid-use", M extends keyof {
     "decorator-missing-dependencies": {
         readonly default: import("@typespec/compiler").CallableMessage<["decorator", "required", "location"]>;
         readonly function: import("@typespec/compiler").CallableMessage<[]>;
@@ -63,6 +13,14 @@ export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
         readonly operation: import("@typespec/compiler").CallableMessage<[]>;
         readonly collectionNavigationPropertiesNotNullable: "Collection-valued navigation properties cannot be nullable.";
         readonly propertyRequiredForCreate: import("@typespec/compiler").CallableMessage<["property", "model"]>;
+        readonly modelMissingNamespace: import("@typespec/compiler").CallableMessage<["model"]>;
+        readonly operationParameterMismatch: import("@typespec/compiler").CallableMessage<["operation", "parameters"]>;
+        readonly topLevelNamespaceMissingPublicNamespace: import("@typespec/compiler").CallableMessage<["namespace"]>;
+        readonly propertyMissingContainsOrReferences: import("@typespec/compiler").CallableMessage<["property", "entity"]>;
+        readonly singletonOrEntitysetHostingBindingsShouldExist: import("@typespec/compiler").CallableMessage<["firstSegment", "target"]>;
+        readonly sharedEntityNotFoundInReferenceLibrary: import("@typespec/compiler").CallableMessage<["model"]>;
+        readonly sharedEntityPropertyNotFoundInReferenceEntity: import("@typespec/compiler").CallableMessage<["property", "model"]>;
+        readonly sharedEntityMustBeSharedInSourceLibrary: import("@typespec/compiler").CallableMessage<["model"]>;
     };
     "decorator-invalid-use": {
         readonly default: import("@typespec/compiler").CallableMessage<["decorator", "other", "location"]>;
@@ -70,53 +28,76 @@ export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
         readonly disallowedTypeSpecDecorators: import("@typespec/compiler").CallableMessage<["decorator"]>;
         readonly expandProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
         readonly filterProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
+        readonly invalidAllPropertiesNotationUsage: import("@typespec/compiler").CallableMessage<[]>;
         readonly key: import("@typespec/compiler").CallableMessage<[]>;
         readonly orderByProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
         readonly required: import("@typespec/compiler").CallableMessage<["decorator", "parameters"]>;
         readonly wrongType: import("@typespec/compiler").CallableMessage<["decorator", "target"]>;
         readonly graphRoute: import("@typespec/compiler").CallableMessage<[]>;
+        readonly allowedValues: import("@typespec/compiler").CallableMessage<[]>;
+        readonly allowedValuesTypeHomogeinity: import("@typespec/compiler").CallableMessage<[]>;
+        readonly allowedValuesInvalidType: import("@typespec/compiler").CallableMessage<[]>;
+        readonly invalidPublicNamespaceName: import("@typespec/compiler").CallableMessage<["namespace"]>;
+        readonly invalidWorkloadNamespaceName: import("@typespec/compiler").CallableMessage<["namespace"]>;
+        readonly partial: import("@typespec/compiler").CallableMessage<[]>;
+        readonly graphDeprecatedMustBeAccompaniedByDefinition: import("@typespec/compiler").CallableMessage<[]>;
+        readonly graphDeprecatedValueMustBeDefinedInDeprecatedDefinition: import("@typespec/compiler").CallableMessage<[]>;
+        readonly ownerlessMustBeAppliedToInterfacesWithSingleSegmentGraphRouteRule: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referencedEntityModelCannotHaveComplexTypeProperties: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referencedEntityModelCanOnlyHaveNavigationProperties: import("@typespec/compiler").CallableMessage<[]>;
+        readonly ownerlessInterfaceCannotHaveAnyNonActionFunctionOperations: import("@typespec/compiler").CallableMessage<[]>;
+        readonly ownerlessDecoratorCannotBeUsedWithIsOwner: import("@typespec/compiler").CallableMessage<[]>;
+        readonly ownerlessDecoratorCannotHaveBaseModel: import("@typespec/compiler").CallableMessage<[]>;
+        readonly entityTypeInOnwerlessCannotBeUsedWithOtherInterfaces: import("@typespec/compiler").CallableMessage<[]>;
+        readonly globalOperationMustBeUsedWithNonRoutedInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly globalOperationMustBeUsedWithProjectBindingType: import("@typespec/compiler").CallableMessage<[]>;
+        readonly graphRouteWithRoutingParameterAsFinalSegment: import("@typespec/compiler").CallableMessage<["graphRoute"]>;
+        readonly referenceTargetInterfaceMustHaveGraphRoute: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referenceTargetMustOnlyBeUsedOnceOnInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referenceTargetPathShouldNotHaveParameters: import("@typespec/compiler").CallableMessage<["decorator", "target"]>;
+        readonly interfaceWithGraphRouteMustExtendGraphStandardBaseInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly duplicateGraphRouteNotAllowed: import("@typespec/compiler").CallableMessage<["graphRoute", "target", "existing"]>;
+        readonly duplicateParametersAreNotAllowedInGraphRoute: import("@typespec/compiler").CallableMessage<["parameters", "graphRoute", "target"]>;
+        readonly complexCannotBeDecoratedWithPartial: import("@typespec/compiler").CallableMessage<[]>;
+        readonly returnSourceOnlyAppliesToActionsAndFunctions: import("@typespec/compiler").CallableMessage<[]>;
+        readonly deltaCanOnlyBeAppliedToFunctionsNamedDelta: import("@typespec/compiler").CallableMessage<[]>;
+        readonly deltaCanOnlyBeUsedWithFunctions: import("@typespec/compiler").CallableMessage<[]>;
+        readonly deltaCanOnlyBeUsedInCollectionInterfacesThatExtendEntityTypes: import("@typespec/compiler").CallableMessage<[]>;
+        readonly interfaceWithDeltaDefinitionMustIncludeAGetOperation: import("@typespec/compiler").CallableMessage<[]>;
+        readonly deltaFunctionReturnTypeMustBeCollectionOfEntityType: import("@typespec/compiler").CallableMessage<[]>;
+        readonly complexTypesAreNotAddressableThroughUniqueUrls: import("@typespec/compiler").CallableMessage<["complexType"]>;
+        readonly entityAndComplexAreMutuallyExclusive: import("@typespec/compiler").CallableMessage<["decorator", "model"]>;
+        readonly filterPropertiesShouldBeSimple: import("@typespec/compiler").CallableMessage<["property", "model"]>;
+        readonly navigationPropertyShouldBeTargettedWithOneInterface: import("@typespec/compiler").CallableMessage<["models"]>;
+        readonly graphRouteMustMatchModelStructure: import("@typespec/compiler").CallableMessage<["graphRoute", "model"]>;
+        readonly overloadedFunctionReturnTypesMustBeSame: import("@typespec/compiler").CallableMessage<["returnTypes", "operation"]>;
+        readonly enumMemberUnknownFutureValueCannotHaveDocString: import("@typespec/compiler").CallableMessage<["member"]>;
+        readonly addressUrlsAreNotEqual: import("@typespec/compiler").CallableMessage<["decorator", "target"]>;
+        readonly partialDeclaringSignatureMustMatchReference: import("@typespec/compiler").CallableMessage<["target", "decorator"]>;
+        readonly openDecoratorCannotBeUsedWithPartial: import("@typespec/compiler").CallableMessage<[]>;
+        readonly interfaceWithGraphRouteTargetingFunctionMustTargetComposableFunction: import("@typespec/compiler").CallableMessage<[]>;
+        readonly graphRouteMustHaveMatchingGraphRoutesForEachSubPath: import("@typespec/compiler").CallableMessage<["subPath", "graphRoute"]>;
+        readonly sharedEntityCannotBePartial: import("@typespec/compiler").CallableMessage<["model"]>;
+        readonly sharedEntityCannotHaveOwner: import("@typespec/compiler").CallableMessage<["model"]>;
+    };
+    "model-invalid-use": {
+        readonly default: import("@typespec/compiler").CallableMessage<["model"]>;
     };
     "singleton-invalid-name": {
         readonly default: import("@typespec/compiler").CallableMessage<["value"]>;
     };
     "extends-invalid-use": {
         readonly default: import("@typespec/compiler").CallableMessage<["type", "type"]>;
+        readonly namespaces: "A model can only extend other models in a different logical namespace. Use @graphPartial instead.";
     };
-    "use-evolvable-enum": {
-        readonly default: import("@typespec/compiler").CallableMessage<["enum"]>;
-    };
-}, Record<string, any>>;
-export declare const reportDiagnostic: <C extends "decorator-missing-dependencies" | "element-missing-dependencies" | "decorator-invalid-use" | "singleton-invalid-name" | "extends-invalid-use" | "use-evolvable-enum", M extends keyof {
-    "decorator-missing-dependencies": {
-        readonly default: import("@typespec/compiler").CallableMessage<["decorator", "required", "location"]>;
-        readonly function: import("@typespec/compiler").CallableMessage<[]>;
-    };
-    "element-missing-dependencies": {
-        readonly default: import("@typespec/compiler").CallableMessage<["element", "other", "location"]>;
-        readonly operation: import("@typespec/compiler").CallableMessage<[]>;
-        readonly collectionNavigationPropertiesNotNullable: "Collection-valued navigation properties cannot be nullable.";
-        readonly propertyRequiredForCreate: import("@typespec/compiler").CallableMessage<["property", "model"]>;
-    };
-    "decorator-invalid-use": {
-        readonly default: import("@typespec/compiler").CallableMessage<["decorator", "other", "location"]>;
-        readonly alternateKey: import("@typespec/compiler").CallableMessage<[]>;
-        readonly disallowedTypeSpecDecorators: import("@typespec/compiler").CallableMessage<["decorator"]>;
-        readonly expandProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
-        readonly filterProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
-        readonly key: import("@typespec/compiler").CallableMessage<[]>;
-        readonly orderByProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
-        readonly required: import("@typespec/compiler").CallableMessage<["decorator", "parameters"]>;
-        readonly wrongType: import("@typespec/compiler").CallableMessage<["decorator", "target"]>;
-        readonly graphRoute: import("@typespec/compiler").CallableMessage<[]>;
-    };
-    "singleton-invalid-name": {
-        readonly default: import("@typespec/compiler").CallableMessage<["value"]>;
-    };
-    "extends-invalid-use": {
-        readonly default: import("@typespec/compiler").CallableMessage<["type", "type"]>;
-    };
-    "use-evolvable-enum": {
-        readonly default: import("@typespec/compiler").CallableMessage<["enum"]>;
+    "type-invalid-use": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+        readonly recordTypeCannotBePrepopulated: import("@typespec/compiler").CallableMessage<["type"]>;
+        readonly recordTypeCannotBeNull: import("@typespec/compiler").CallableMessage<["type"]>;
+        readonly recordTypeCannotBeUsedInLine: import("@typespec/compiler").CallableMessage<["type"]>;
+        readonly interfaceWithPartialBindingType: import("@typespec/compiler").CallableMessage<["interface", "type"]>;
+        readonly propertyTypeCannotBeStringLiteral: import("@typespec/compiler").CallableMessage<["property", "type"]>;
+        readonly sharedEntityCannotCreateSingletonOrEntitySet: import("@typespec/compiler").CallableMessage<["type"]>;
     };
 }[C]>(program: import("@typespec/compiler").Program, diag: import("@typespec/compiler").DiagnosticReport<{
     "decorator-missing-dependencies": {
@@ -128,6 +109,14 @@ export declare const reportDiagnostic: <C extends "decorator-missing-dependencie
         readonly operation: import("@typespec/compiler").CallableMessage<[]>;
         readonly collectionNavigationPropertiesNotNullable: "Collection-valued navigation properties cannot be nullable.";
         readonly propertyRequiredForCreate: import("@typespec/compiler").CallableMessage<["property", "model"]>;
+        readonly modelMissingNamespace: import("@typespec/compiler").CallableMessage<["model"]>;
+        readonly operationParameterMismatch: import("@typespec/compiler").CallableMessage<["operation", "parameters"]>;
+        readonly topLevelNamespaceMissingPublicNamespace: import("@typespec/compiler").CallableMessage<["namespace"]>;
+        readonly propertyMissingContainsOrReferences: import("@typespec/compiler").CallableMessage<["property", "entity"]>;
+        readonly singletonOrEntitysetHostingBindingsShouldExist: import("@typespec/compiler").CallableMessage<["firstSegment", "target"]>;
+        readonly sharedEntityNotFoundInReferenceLibrary: import("@typespec/compiler").CallableMessage<["model"]>;
+        readonly sharedEntityPropertyNotFoundInReferenceEntity: import("@typespec/compiler").CallableMessage<["property", "model"]>;
+        readonly sharedEntityMustBeSharedInSourceLibrary: import("@typespec/compiler").CallableMessage<["model"]>;
     };
     "decorator-invalid-use": {
         readonly default: import("@typespec/compiler").CallableMessage<["decorator", "other", "location"]>;
@@ -135,20 +124,76 @@ export declare const reportDiagnostic: <C extends "decorator-missing-dependencie
         readonly disallowedTypeSpecDecorators: import("@typespec/compiler").CallableMessage<["decorator"]>;
         readonly expandProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
         readonly filterProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
+        readonly invalidAllPropertiesNotationUsage: import("@typespec/compiler").CallableMessage<[]>;
         readonly key: import("@typespec/compiler").CallableMessage<[]>;
         readonly orderByProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
         readonly required: import("@typespec/compiler").CallableMessage<["decorator", "parameters"]>;
         readonly wrongType: import("@typespec/compiler").CallableMessage<["decorator", "target"]>;
         readonly graphRoute: import("@typespec/compiler").CallableMessage<[]>;
+        readonly allowedValues: import("@typespec/compiler").CallableMessage<[]>;
+        readonly allowedValuesTypeHomogeinity: import("@typespec/compiler").CallableMessage<[]>;
+        readonly allowedValuesInvalidType: import("@typespec/compiler").CallableMessage<[]>;
+        readonly invalidPublicNamespaceName: import("@typespec/compiler").CallableMessage<["namespace"]>;
+        readonly invalidWorkloadNamespaceName: import("@typespec/compiler").CallableMessage<["namespace"]>;
+        readonly partial: import("@typespec/compiler").CallableMessage<[]>;
+        readonly graphDeprecatedMustBeAccompaniedByDefinition: import("@typespec/compiler").CallableMessage<[]>;
+        readonly graphDeprecatedValueMustBeDefinedInDeprecatedDefinition: import("@typespec/compiler").CallableMessage<[]>;
+        readonly ownerlessMustBeAppliedToInterfacesWithSingleSegmentGraphRouteRule: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referencedEntityModelCannotHaveComplexTypeProperties: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referencedEntityModelCanOnlyHaveNavigationProperties: import("@typespec/compiler").CallableMessage<[]>;
+        readonly ownerlessInterfaceCannotHaveAnyNonActionFunctionOperations: import("@typespec/compiler").CallableMessage<[]>;
+        readonly ownerlessDecoratorCannotBeUsedWithIsOwner: import("@typespec/compiler").CallableMessage<[]>;
+        readonly ownerlessDecoratorCannotHaveBaseModel: import("@typespec/compiler").CallableMessage<[]>;
+        readonly entityTypeInOnwerlessCannotBeUsedWithOtherInterfaces: import("@typespec/compiler").CallableMessage<[]>;
+        readonly globalOperationMustBeUsedWithNonRoutedInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly globalOperationMustBeUsedWithProjectBindingType: import("@typespec/compiler").CallableMessage<[]>;
+        readonly graphRouteWithRoutingParameterAsFinalSegment: import("@typespec/compiler").CallableMessage<["graphRoute"]>;
+        readonly referenceTargetInterfaceMustHaveGraphRoute: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referenceTargetMustOnlyBeUsedOnceOnInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referenceTargetPathShouldNotHaveParameters: import("@typespec/compiler").CallableMessage<["decorator", "target"]>;
+        readonly interfaceWithGraphRouteMustExtendGraphStandardBaseInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly duplicateGraphRouteNotAllowed: import("@typespec/compiler").CallableMessage<["graphRoute", "target", "existing"]>;
+        readonly duplicateParametersAreNotAllowedInGraphRoute: import("@typespec/compiler").CallableMessage<["parameters", "graphRoute", "target"]>;
+        readonly complexCannotBeDecoratedWithPartial: import("@typespec/compiler").CallableMessage<[]>;
+        readonly returnSourceOnlyAppliesToActionsAndFunctions: import("@typespec/compiler").CallableMessage<[]>;
+        readonly deltaCanOnlyBeAppliedToFunctionsNamedDelta: import("@typespec/compiler").CallableMessage<[]>;
+        readonly deltaCanOnlyBeUsedWithFunctions: import("@typespec/compiler").CallableMessage<[]>;
+        readonly deltaCanOnlyBeUsedInCollectionInterfacesThatExtendEntityTypes: import("@typespec/compiler").CallableMessage<[]>;
+        readonly interfaceWithDeltaDefinitionMustIncludeAGetOperation: import("@typespec/compiler").CallableMessage<[]>;
+        readonly deltaFunctionReturnTypeMustBeCollectionOfEntityType: import("@typespec/compiler").CallableMessage<[]>;
+        readonly complexTypesAreNotAddressableThroughUniqueUrls: import("@typespec/compiler").CallableMessage<["complexType"]>;
+        readonly entityAndComplexAreMutuallyExclusive: import("@typespec/compiler").CallableMessage<["decorator", "model"]>;
+        readonly filterPropertiesShouldBeSimple: import("@typespec/compiler").CallableMessage<["property", "model"]>;
+        readonly navigationPropertyShouldBeTargettedWithOneInterface: import("@typespec/compiler").CallableMessage<["models"]>;
+        readonly graphRouteMustMatchModelStructure: import("@typespec/compiler").CallableMessage<["graphRoute", "model"]>;
+        readonly overloadedFunctionReturnTypesMustBeSame: import("@typespec/compiler").CallableMessage<["returnTypes", "operation"]>;
+        readonly enumMemberUnknownFutureValueCannotHaveDocString: import("@typespec/compiler").CallableMessage<["member"]>;
+        readonly addressUrlsAreNotEqual: import("@typespec/compiler").CallableMessage<["decorator", "target"]>;
+        readonly partialDeclaringSignatureMustMatchReference: import("@typespec/compiler").CallableMessage<["target", "decorator"]>;
+        readonly openDecoratorCannotBeUsedWithPartial: import("@typespec/compiler").CallableMessage<[]>;
+        readonly interfaceWithGraphRouteTargetingFunctionMustTargetComposableFunction: import("@typespec/compiler").CallableMessage<[]>;
+        readonly graphRouteMustHaveMatchingGraphRoutesForEachSubPath: import("@typespec/compiler").CallableMessage<["subPath", "graphRoute"]>;
+        readonly sharedEntityCannotBePartial: import("@typespec/compiler").CallableMessage<["model"]>;
+        readonly sharedEntityCannotHaveOwner: import("@typespec/compiler").CallableMessage<["model"]>;
+    };
+    "model-invalid-use": {
+        readonly default: import("@typespec/compiler").CallableMessage<["model"]>;
     };
     "singleton-invalid-name": {
         readonly default: import("@typespec/compiler").CallableMessage<["value"]>;
     };
     "extends-invalid-use": {
         readonly default: import("@typespec/compiler").CallableMessage<["type", "type"]>;
-    };
-    "use-evolvable-enum": {
-        readonly default: import("@typespec/compiler").CallableMessage<["enum"]>;
+        readonly namespaces: "A model can only extend other models in a different logical namespace. Use @graphPartial instead.";
+    };
+    "type-invalid-use": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+        readonly recordTypeCannotBePrepopulated: import("@typespec/compiler").CallableMessage<["type"]>;
+        readonly recordTypeCannotBeNull: import("@typespec/compiler").CallableMessage<["type"]>;
+        readonly recordTypeCannotBeUsedInLine: import("@typespec/compiler").CallableMessage<["type"]>;
+        readonly interfaceWithPartialBindingType: import("@typespec/compiler").CallableMessage<["interface", "type"]>;
+        readonly propertyTypeCannotBeStringLiteral: import("@typespec/compiler").CallableMessage<["property", "type"]>;
+        readonly sharedEntityCannotCreateSingletonOrEntitySet: import("@typespec/compiler").CallableMessage<["type"]>;
     };
 }, C, M>) => void;
 //# sourceMappingURL=lib.d.ts.map

package/dist/src/lib.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/lib.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,qBAAqB,CAAC;AAE5C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDT,CAAC;AAEX,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAgC,CAAC;AAClD,eAAO,MAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAS,CAAC"}
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/lib.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,YAAY,CAAC;AAEnC,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAeD,eAAO,MAAM,MAAM,2CAEjB,CAAC;AAEH,eAAO,MAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyHpB,CAAC"}

package/dist/src/lib.js

@@ -1,6 +1,21 @@
-import { createTypeSpecLibrary, paramMessage } from "@typespec/compiler";
-export const namespace = "TypeSpec.MsGraph";
-export const libDef = {
+import { createTypeSpecLibrary, definePackageFlags, paramMessage } from "@typespec/compiler";
+export const namespace = "MsGraph";
+const EmitterOptionsSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        filename: {
+            type: "string",
+            nullable: true,
+            description: "The name of the generated CSDL file. If not specified, it defaults to `workload.csdl`."
+        },
+    },
+    required: [],
+};
+export const $flags = definePackageFlags({
+    decoratorArgMarshalling: "new",
+});
+export const { reportDiagnostic } = createTypeSpecLibrary({
     name: "@microsoft/typespec-msgraph",
     diagnostics: {
         "decorator-missing-dependencies": {
@@ -17,6 +32,14 @@ export const libDef = {
                 operation: paramMessage `Operations must be used inside interfaces.`,
                 collectionNavigationPropertiesNotNullable: `Collection-valued navigation properties cannot be nullable.`,
                 propertyRequiredForCreate: paramMessage `The property "${"property"}" on "${"model"}" must be nullable, computed, have a default value or be annotated with @requiredForCreate.`,
+                modelMissingNamespace: paramMessage `The model "${"model"}" must be defined in a namespace.`,
+                operationParameterMismatch: paramMessage `The operation "${"operation"}" must declare the parameters "${"parameters"}", have a "graphRouteParams" parameter or use the porcelain syntax.`,
+                topLevelNamespaceMissingPublicNamespace: paramMessage `@publicNamespace decorator is required on namespace "${"namespace"}".`,
+                propertyMissingContainsOrReferences: paramMessage `The property "${"property"}" of type "${"entity"}" which is an entity must have @contains or @references.`,
+                singletonOrEntitysetHostingBindingsShouldExist: paramMessage `A singleton or entityset definition should exist to bind "${"firstSegment"}" to "${"target"}".`,
+                sharedEntityNotFoundInReferenceLibrary: paramMessage `The shared entity "${"model"}" does not exist in the reference library.`,
+                sharedEntityPropertyNotFoundInReferenceEntity: paramMessage `The property "${"property"}" in the shared entity "${"model"}" must also exist in the reference library entity.`,
+                sharedEntityMustBeSharedInSourceLibrary: paramMessage `The declared shared entity "${"model"}" must also be defined as a shared entity in the source library.`,
             },
         },
         "decorator-invalid-use": {
@@ -27,13 +50,65 @@ export const libDef = {
                 disallowedTypeSpecDecorators: paramMessage `The decorator ${"decorator"} may not be used in MSGraph TypeSpec.`,
                 expandProperties: paramMessage `The properties "${"properties"}" defined in the @expand decorator must be defined with @references or @contains in the referenced model "${"model"}" or its inheritance hierarchy.`,
                 filterProperties: paramMessage `The properties "${"properties"}" defined in the @filter decorator must be defined in the referenced model "${"model"}" or its inheritance hierarchy.`,
+                invalidAllPropertiesNotationUsage: paramMessage `The all-properties notation * cannot be used alongside other properties in the @filter decorator.`,
                 key: paramMessage `The @key decorator can only be attached to a non-nullable primitive type.`,
                 orderByProperties: paramMessage `The properties "${"properties"}" defined in the @orderBy decorator must not be defined with @references or @contains in the referenced model "${"model"}" or its inheritance hierarchy.`,
                 required: paramMessage `The ${"decorator"} decorator must define required ${"parameters"}.`,
                 wrongType: paramMessage `The ${"decorator"} decorator can only be applied to a ${"target"}.`,
                 graphRoute: paramMessage `@graphRoutes paths must not start with a /`,
+                allowedValues: paramMessage `The @allowedValues decorator cannot be empty.`,
+                allowedValuesTypeHomogeinity: paramMessage `The types of values passed to @allowedValues must be homegeneous.`,
+                allowedValuesInvalidType: paramMessage `The @allowedValues decorator can only be applied with primitive types.`,
+                invalidPublicNamespaceName: paramMessage `The @publicNamespace decorator value on namespace "${"namespace"}" should start with "microsoft.graph".`,
+                invalidWorkloadNamespaceName: paramMessage `The @workloadNamespace decorator value on namespace "${"namespace"}" should NOT start with "microsoft.graph".`,
+                partial: paramMessage `The base model in the extended clause must match the base class of the referenced entity in the @graphPartial decorator.`,
+                graphDeprecatedMustBeAccompaniedByDefinition: paramMessage `The @graphDeprecated decorator must be accompanied by @deprecatedDefinition on the namespace.`,
+                graphDeprecatedValueMustBeDefinedInDeprecatedDefinition: paramMessage `The @graphDeprecated value must be defined in the @deprecatedDefinition decorator on the namespace.`,
+                ownerlessMustBeAppliedToInterfacesWithSingleSegmentGraphRouteRule: paramMessage `The @ownerless decorator can only be applied to interfaces with a single segment @graphRoute.`,
+                referencedEntityModelCannotHaveComplexTypeProperties: paramMessage `The referenced entity model cannot have complex type properties.`,
+                referencedEntityModelCanOnlyHaveNavigationProperties: paramMessage `The referenced entity model can only have navigation properties.`,
+                ownerlessInterfaceCannotHaveAnyNonActionFunctionOperations: paramMessage `The @ownerless decorator can only be applied to interfaces that contain only action or function operations.`,
+                ownerlessDecoratorCannotBeUsedWithIsOwner: paramMessage `The referenced model in the ownerless interface cannot be used with @isOwner decorator.`,
+                ownerlessDecoratorCannotHaveBaseModel: paramMessage `The referenced model in the ownerless interface cannot have a base model.`,
+                entityTypeInOnwerlessCannotBeUsedWithOtherInterfaces: paramMessage `The referenced model in the ownerless interface cannot be used in the extends clause of other interfaces.`,
+                globalOperationMustBeUsedWithNonRoutedInterface: paramMessage `The @globalOperation decorator must be used on an operation with a non-routed interface.`,
+                globalOperationMustBeUsedWithProjectBindingType: paramMessage `The @globalOperation decorator must be used on an operation that has a local model binding the interface.`,
+                graphRouteWithRoutingParameterAsFinalSegment: paramMessage `The @graphRoute ${"graphRoute"} with a routing parameter as the last segment cannot be used with a collection interface.`,
+                referenceTargetInterfaceMustHaveGraphRoute: paramMessage `The @referenceTarget decorator must be used on an interface with a @graphRoute decorator.`,
+                referenceTargetMustOnlyBeUsedOnceOnInterface: paramMessage `The @referenceTarget decorator can only be used once on an interface.`,
+                referenceTargetPathShouldNotHaveParameters: paramMessage `The decorator "${"decorator"}" path "${"target"}" cannot have parameters {}.`,
+                interfaceWithGraphRouteMustExtendGraphStandardBaseInterface: paramMessage `The @graphRoute decorator can only be used on an interface that ultimately extends a Graph standard base interface i.e. Resource<T> or Collection<T>.`,
+                duplicateGraphRouteNotAllowed: paramMessage `The @graphRoute "${"graphRoute"}" on "${"target"}" is already defined on another interface "${"existing"}".`,
+                duplicateParametersAreNotAllowedInGraphRoute: paramMessage `The parameters "${"parameters"}" on the @graphRoute "${"graphRoute"}" for "${"target"}" must have unique names.`,
+                complexCannotBeDecoratedWithPartial: paramMessage `A @complex type cannot be a @graphPartial.`,
+                returnSourceOnlyAppliesToActionsAndFunctions: paramMessage `The @returnSource decorator can only be applied to @function and @action operations.`,
+                deltaCanOnlyBeAppliedToFunctionsNamedDelta: paramMessage `The @delta decorator can only be used with @function operations named delta.`,
+                deltaCanOnlyBeUsedWithFunctions: paramMessage `The @delta decorator can only be used with @function operations.`,
+                deltaCanOnlyBeUsedInCollectionInterfacesThatExtendEntityTypes: paramMessage `The @delta decorator can only be used in collection interfaces that extend entity types.`,
+                interfaceWithDeltaDefinitionMustIncludeAGetOperation: paramMessage `Interfaces with @delta definition must include a get operation.`,
+                deltaFunctionReturnTypeMustBeCollectionOfEntityType: paramMessage `The return type of a @delta function must be a collection of entity type.`,
+                complexTypesAreNotAddressableThroughUniqueUrls: paramMessage `The complex type "${"complexType"}" cannot be addressed through unique URLs.`,
+                entityAndComplexAreMutuallyExclusive: paramMessage `The ${"decorator"} and @complex decorators are mutually exclusive and cannot be used together on "${"model"}" model.`,
+                filterPropertiesShouldBeSimple: paramMessage `The property "${"property"}" defined in the @filter decorator must be a simple property in the model "${"model"}".`,
+                navigationPropertyShouldBeTargettedWithOneInterface: paramMessage `The navigation properties "${"models"}" should not be targetted by more than one interface with @delta. Please choose one interface for each navigation property.`,
+                graphRouteMustMatchModelStructure: paramMessage `The @graphRoute "${"graphRoute"}" must match a navigation path in the model "${"model"}".`,
+                overloadedFunctionReturnTypesMustBeSame: paramMessage `The return types "${"returnTypes"}" of the overloaded function "${"operation"}" must be identical.`,
+                enumMemberUnknownFutureValueCannotHaveDocString: paramMessage `Description is not allowed on "${"member"}" because it will be auto-generated.`,
+                addressUrlsAreNotEqual: paramMessage `The decorator values (string and booleans) of "${"decorator"}" applied to multiple interfaces that point to the same navigation property "${"target"}" must be identical.`,
+                partialDeclaringSignatureMustMatchReference: paramMessage `The declaring signature of the partial entity "${"target"}" must match the referenced entity's, with the same use of the ${"decorator"} decorator.`,
+                openDecoratorCannotBeUsedWithPartial: paramMessage `The @open decorator can only be specified in the the owning workload.`,
+                interfaceWithGraphRouteTargetingFunctionMustTargetComposableFunction: paramMessage `An interface with a @graphroute decorator targeting a function must target a composable function.`,
+                graphRouteMustHaveMatchingGraphRoutesForEachSubPath: paramMessage `Missing matching @graphRoute for subpath "${"subPath"}" of path "${"graphRoute"}".`,
+                sharedEntityCannotBePartial: paramMessage `The @sharedEntity and @graphPartial decorators cannot be used together on "${"model"}" model.`,
+                sharedEntityCannotHaveOwner: paramMessage `The @sharedEntity decorator cannot be used with ownership decorator values set to true on "${"model"}" model.`,
             },
         },
+        "model-invalid-use": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Model '${"model"}' should be an operationParameter, entity or complex type.`,
+            }
+        },
         "singleton-invalid-name": {
             severity: "error",
             messages: {
@@ -44,16 +119,22 @@ export const libDef = {
             severity: "error",
             messages: {
                 default: paramMessage `A ${"type"} model can only extend a ${"type"} baseModel`,
+                namespaces: 'A model can only extend other models in a different logical namespace. Use @graphPartial instead.'
             },
         },
-        "use-evolvable-enum": {
-            severity: "warning",
+        "type-invalid-use": {
+            severity: "error",
             messages: {
-                default: paramMessage `Enumeration '${"enum"}' should have a member named unknownFutureValue for future extensibility.`,
-            },
-        },
+                default: paramMessage `The ${"type"} has been wrongly used. Refer to Typespec documentation`,
+                recordTypeCannotBePrepopulated: paramMessage `The record type "${"type"}" cannot be prepopulated.`,
+                recordTypeCannotBeNull: paramMessage `The record type "${"type"}" cannot be null.`,
+                recordTypeCannotBeUsedInLine: paramMessage `Using inline record as type on ${"type"} is not supported. Create a complex entity to represent it.`,
+                interfaceWithPartialBindingType: paramMessage `The interface "${"interface"}" targets a partial or non-owned type "${"type"}" and as such cannot declare operations.`,
+                propertyTypeCannotBeStringLiteral: paramMessage `The type for "${"property"}" cannot be a ${"type"} literal.`,
+                sharedEntityCannotCreateSingletonOrEntitySet: paramMessage `The shared entity "${"type"}" cannot be the type of a routed interface that creates a Singleton or an EntitySet`,
+            }
+        }
     },
-};
-export const $lib = createTypeSpecLibrary(libDef);
-export const { reportDiagnostic } = $lib;
+    emitter: { options: EmitterOptionsSchema },
+});
 //# sourceMappingURL=lib.js.map

package/dist/src/lib.js.map

@@ -1 +1 @@
-{"version":3,"file":"lib.js","sourceRoot":"","sources":["../../src/lib.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEzE,MAAM,CAAC,MAAM,SAAS,GAAG,kBAAkB,CAAC;AAE5C,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,6BAA6B;IACnC,WAAW,EAAE;QACX,gCAAgC,EAAE;YAChC,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,OAAO,WAAW,sDAAsD,UAAU,qBAAqB,UAAU,GAAG;gBACzI,QAAQ,EAAE,YAAY,CAAA,oFAAoF;aAC3G;SACF;QACD,8BAA8B,EAAE;YAC9B,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,OAAO,SAAS,+BAA+B,OAAO,SAAS,UAAU,GAAG;gBACjG,SAAS,EAAE,YAAY,CAAA,4CAA4C;gBACnE,yCAAyC,EAAE,6DAA6D;gBACxG,yBAAyB,EAAE,YAAY,CAAA,iBAAiB,UAAU,SAAS,OAAO,6FAA6F;aAChL;SACF;QACD,uBAAuB,EAAE;YACvB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,OAAO,WAAW,2CAA2C,OAAO,SAAS,UAAU,GAAG;gBAC/G,YAAY,EAAE,YAAY,CAAA,8FAA8F;gBACxH,4BAA4B,EAAE,YAAY,CAAA,iBAAiB,WAAW,uCAAuC;gBAC7G,gBAAgB,EAAE,YAAY,CAAA,mBAAmB,YAAY,6GAA6G,OAAO,iCAAiC;gBAClN,gBAAgB,EAAE,YAAY,CAAA,mBAAmB,YAAY,+EAA+E,OAAO,iCAAiC;gBACpL,GAAG,EAAE,YAAY,CAAA,2EAA2E;gBAC5F,iBAAiB,EAAE,YAAY,CAAA,mBAAmB,YAAY,kHAAkH,OAAO,iCAAiC;gBACxN,QAAQ,EAAE,YAAY,CAAA,OAAO,WAAW,mCAAmC,YAAY,GAAG;gBAC1F,SAAS,EAAE,YAAY,CAAA,OAAO,WAAW,uCAAuC,QAAQ,GAAG;gBAC3F,UAAU,EAAE,YAAY,CAAA,4CAA4C;aACrE;SACF;QACD,wBAAwB,EAAE;YACxB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,wCAAwC,OAAO,uEAAuE;aAC5I;SACF;QACD,qBAAqB,EAAE;YACrB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,KAAK,MAAM,4BAA4B,MAAM,YAAY;aAC/E;SACF;QACD,oBAAoB,EAAE;YACpB,QAAQ,EAAE,SAAS;YACnB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,gBAAgB,MAAM,2EAA2E;aACvH;SACF;KACF;CACO,CAAC;AAEX,MAAM,CAAC,MAAM,IAAI,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAClD,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAAC"}
+{"version":3,"file":"lib.js","sourceRoot":"","sources":["../../src/lib.ts"],"names":[],"mappings":"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"}

package/dist/src/linter.d.ts

@@ -1,3 +1,2 @@
-import { Program } from "@typespec/compiler";
-export declare function $onValidate(program: Program): void;
+export declare const $linter: import("@typespec/compiler").LinterDefinition;
 //# sourceMappingURL=linter.d.ts.map

package/dist/src/linter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linter.d.ts","sourceRoot":"","sources":["../../src/linter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAwC7C,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,QAG3C"}
+{"version":3,"file":"linter.d.ts","sourceRoot":"","sources":["../../src/linter.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,OAAO,+CA6BlB,CAAC"}

package/dist/src/linter.js

@@ -1,39 +1,33 @@
-import { getLinter } from "@typespec/lint";
-import { $lib } from "./lib.js";
-import * as theRules from "./rules/index.js";
-const linter = getLinter($lib);
-linter.registerRules([
-    theRules.abstractOnlyAppliesToStructuredTypeRule,
-    theRules.alternateKeyOnKeyRule,
-    theRules.alternateKeyOnPrimitivePropertyRule,
-    theRules.alternateKeyRequiresKeyRule,
-    theRules.computedCannotBeCombinedWithRule,
-    theRules.containsOnlyAppliesToNavigationPropertyRule,
-    theRules.countAppliesToGetOperationsThatReturnCollectionsRule,
-    theRules.disallowedTypeSpecDecoratorsRule,
-    theRules.entityMustHaveKeyRule,
-    theRules.expandOnlyNavigationPropertiesRule,
-    theRules.expandOnlyOnGetNavigationSourceRule,
-    theRules.extendsOnSameTypeRule,
-    theRules.filterAppliesToGetOperationsThatReturnCollectionsRule,
-    theRules.filterOnlyAppliesToModelPropertiesRule,
-    theRules.filterPropertiesMustNotBeEmptyRule,
-    theRules.hasStreamOnlyOnEntity,
-    theRules.keyOnlyOnEntityNonNullablePrimitivePropertyRule,
-    theRules.openOnlyAppliesToStructuredType,
-    theRules.operationInsideInterfaceRule,
-    theRules.orderByOnlyNonNavigationPropertiesRule,
-    theRules.orderByAppliesToGetOperationsThatReturnCollectionsRule,
-    theRules.referencesOnlyAppliesToNavigationPropertyRule,
-    theRules.searchAppliesToGetOperationsThatReturnCollectionsRule,
-    theRules.skipAppliesToGetOperationsThatReturnCollectionsRule,
-    theRules.topAppliesToGetOperationsThatReturnCollectionsRule,
-    theRules.useEvolvableEnumRule,
-    theRules.voidFunctionRule,
-    theRules.graphRouteLeadingSlashRule,
-], { autoEnable: true });
-export function $onValidate(program) {
-    linter.autoEnableRules();
-    linter.lintOnValidate(program);
-}
+import { defineLinter } from "@typespec/compiler";
+import { useEvolvableEnumRule, mediaTypeValuesShouldBeMinimallyFormattedForMIMETypes, interfaceNavigationSourceShouldHaveMediaIf$ValueIsSpecified, getPutPostAndPatchOperationsShouldHaveSelectDecorator, useRecordTypeInsteadOfDictionary, dictionaryTypeIsMostlyUsedWithRecordType, containedNavigationPropertyTypeShouldNotBeExternallyReferenced, entityAndComplexPropertyNameShouldNotBeName, validateCoreElementsHaveDocString, operationParametersShouldHaveRequiredBeforeOptional } from "./rules/index.js";
+export const $linter = defineLinter({
+    rules: [
+        useEvolvableEnumRule,
+        mediaTypeValuesShouldBeMinimallyFormattedForMIMETypes,
+        interfaceNavigationSourceShouldHaveMediaIf$ValueIsSpecified,
+        getPutPostAndPatchOperationsShouldHaveSelectDecorator,
+        useRecordTypeInsteadOfDictionary,
+        dictionaryTypeIsMostlyUsedWithRecordType,
+        containedNavigationPropertyTypeShouldNotBeExternallyReferenced,
+        entityAndComplexPropertyNameShouldNotBeName,
+        validateCoreElementsHaveDocString,
+        operationParametersShouldHaveRequiredBeforeOptional
+    ],
+    ruleSets: {
+        recommended: {
+            enable: {
+                [`@microsoft/typespec-msgraph/${useEvolvableEnumRule.name}`]: true,
+                [`@microsoft/typespec-msgraph/${mediaTypeValuesShouldBeMinimallyFormattedForMIMETypes.name}`]: true,
+                [`@microsoft/typespec-msgraph/${interfaceNavigationSourceShouldHaveMediaIf$ValueIsSpecified.name}`]: true,
+                [`@microsoft/typespec-msgraph/${getPutPostAndPatchOperationsShouldHaveSelectDecorator.name}`]: true,
+                [`@microsoft/typespec-msgraph/${useRecordTypeInsteadOfDictionary.name}`]: true,
+                [`@microsoft/typespec-msgraph/${dictionaryTypeIsMostlyUsedWithRecordType.name}`]: true,
+                [`@microsoft/typespec-msgraph/${containedNavigationPropertyTypeShouldNotBeExternallyReferenced.name}`]: true,
+                [`@microsoft/typespec-msgraph/${entityAndComplexPropertyNameShouldNotBeName.name}`]: true,
+                [`@microsoft/typespec-msgraph/${validateCoreElementsHaveDocString.name}`]: true,
+                [`@microsoft/typespec-msgraph/${operationParametersShouldHaveRequiredBeforeOptional.name}`]: true,
+            }
+        }
+    }
+});
 //# sourceMappingURL=linter.js.map

package/dist/src/linter.js.map

@@ -1 +1 @@
-{"version":3,"file":"linter.js","sourceRoot":"","sources":["../../src/linter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAChC,OAAQ,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAE9C,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;AAC/B,MAAM,CAAC,aAAa,CAClB;IACE,QAAQ,CAAC,uCAAuC;IAChD,QAAQ,CAAC,qBAAqB;IAC9B,QAAQ,CAAC,mCAAmC;IAC5C,QAAQ,CAAC,2BAA2B;IACpC,QAAQ,CAAC,gCAAgC;IACzC,QAAQ,CAAC,2CAA2C;IACpD,QAAQ,CAAC,oDAAoD;IAC7D,QAAQ,CAAC,gCAAgC;IACzC,QAAQ,CAAC,qBAAqB;IAC9B,QAAQ,CAAC,kCAAkC;IAC3C,QAAQ,CAAC,mCAAmC;IAC5C,QAAQ,CAAC,qBAAqB;IAC9B,QAAQ,CAAC,qDAAqD;IAC9D,QAAQ,CAAC,sCAAsC;IAC/C,QAAQ,CAAC,kCAAkC;IAC3C,QAAQ,CAAC,qBAAqB;IAC9B,QAAQ,CAAC,+CAA+C;IACxD,QAAQ,CAAC,+BAA+B;IACxC,QAAQ,CAAC,4BAA4B;IACrC,QAAQ,CAAC,sCAAsC;IAC/C,QAAQ,CAAC,sDAAsD;IAC/D,QAAQ,CAAC,6CAA6C;IACtD,QAAQ,CAAC,qDAAqD;IAC9D,QAAQ,CAAC,mDAAmD;IAC5D,QAAQ,CAAC,kDAAkD;IAC3D,QAAQ,CAAC,oBAAoB;IAC7B,QAAQ,CAAC,gBAAgB;IACzB,QAAQ,CAAC,0BAA0B;CACpC,EACD,EAAE,UAAU,EAAE,IAAI,EAAE,CACrB,CAAC;AAEF,MAAM,UAAU,WAAW,CAAC,OAAgB;IAC1C,MAAM,CAAC,eAAe,EAAE,CAAC;IACzB,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;AACjC,CAAC"}
+{"version":3,"file":"linter.js","sourceRoot":"","sources":["../../src/linter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EACL,oBAAoB,EACpB,qDAAqD,EACrD,2DAA2D,EAC3D,qDAAqD,EACrD,gCAAgC,EAChC,wCAAwC,EACxC,8DAA8D,EAC9D,2CAA2C,EAC3C,iCAAiC,EACjC,mDAAmD,EACpD,MAAM,kBAAkB,CAAC;AAE1B,MAAM,CAAC,MAAM,OAAO,GAAG,YAAY,CAAC;IAClC,KAAK,EAAE;QACL,oBAAoB;QACpB,qDAAqD;QACrD,2DAA2D;QAC3D,qDAAqD;QACrD,gCAAgC;QAChC,wCAAwC;QACxC,8DAA8D;QAC9D,2CAA2C;QAC3C,iCAAiC;QACjC,mDAAmD;KACpD;IACD,QAAQ,EAAE;QACR,WAAW,EAAE;YACX,MAAM,EAAE;gBACN,CAAC,+BAA+B,oBAAoB,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;gBAClE,CAAC,+BAA+B,qDAAqD,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;gBACnG,CAAC,+BAA+B,2DAA2D,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;gBACzG,CAAC,+BAA+B,qDAAqD,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;gBACnG,CAAC,+BAA+B,gCAAgC,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;gBAC9E,CAAC,+BAA+B,wCAAwC,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;gBACtF,CAAC,+BAA+B,8DAA8D,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;gBAC5G,CAAC,+BAA+B,2CAA2C,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;gBACzF,CAAC,+BAA+B,iCAAiC,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;gBAC/E,CAAC,+BAA+B,mDAAmD,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI;aAClG;SACF;KACF;CACF,CAAC,CAAC"}

package/dist/src/path-tree.d.ts

@@ -0,0 +1,16 @@
+import { Model } from "@typespec/compiler";
+export declare class TreeNode {
+    name: string;
+    entityType: Model | undefined;
+    containingEntityType: Model | undefined;
+    children: Map<string, TreeNode>;
+    constructor(entityType?: Model | undefined);
+}
+export declare class PathTree {
+    root: TreeNode;
+    constructor();
+    addNode(path: string, entityType: Model): void;
+    getAllNodesWithContainingEntityType(entityName: string, node?: TreeNode, result?: TreeNode[]): TreeNode[];
+    getNodeByPath(path: string): TreeNode | undefined;
+}
+//# sourceMappingURL=path-tree.d.ts.map

package/dist/src/path-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-tree.d.ts","sourceRoot":"","sources":["../../src/path-tree.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAM3C,qBAAa,QAAQ;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,KAAK,GAAG,SAAS,CAAC;IAC9B,oBAAoB,EAAE,KAAK,GAAG,SAAS,CAAC;IACxC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBAEpB,UAAU,GAAE,KAAK,GAAG,SAAqB;CAMtD;AAKD,qBAAa,QAAQ;IACnB,IAAI,EAAE,QAAQ,CAAC;;IAOf,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,GAAG,IAAI;IAkC9C,mCAAmC,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,GAAE,QAAoB,EAAE,MAAM,GAAE,QAAQ,EAAO,GAAG,QAAQ,EAAE;IAWxH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;CAelD"}