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

package/dist/src/entities/property.js

@@ -0,0 +1,57 @@
+import { getPropertyTypeName } from "../utils.js";
+export function getDefaultPropertyValue(program, property) {
+    if (!property.default) {
+        return undefined;
+    }
+    let defaultValueValue = undefined;
+    switch (property.default.kind) {
+        case "String":
+        case "Boolean":
+        case "Number":
+            defaultValueValue = property.default.value;
+            break;
+        default:
+            return undefined;
+    }
+    const propType = getPropertyTypeName(program, property.type);
+    let defaultValueKey = "String";
+    switch (propType) {
+        case "Edm.String":
+            defaultValueKey = "String";
+            break;
+        case "Collection(Edm.Byte)":
+            defaultValueKey = "Binary";
+            break;
+        case "Edm.Byte":
+        case "Edm.Int16":
+        case "Edm.Int32":
+        case "Edm.Int64":
+            defaultValueKey = "Int";
+            break;
+        case "Edm.Single":
+        case "Edm.Double":
+            defaultValueKey = "Single";
+            break;
+        case "Edm.Date":
+            defaultValueKey = "Date";
+            break;
+        case "Edm.DateTimeOffset":
+            defaultValueKey = "DateTimeOffset";
+            break;
+        case "Edm.Boolean":
+            defaultValueKey = "Boolean";
+            break;
+        case "Edm.Stream":
+            defaultValueKey = "Binary";
+            break;
+        case "Edm.Guid":
+            defaultValueKey = "Guid";
+            break;
+        case "Edm.Duration":
+        case "Edm.TimeOfDay":
+        default:
+            return undefined;
+    }
+    return { [defaultValueKey]: defaultValueValue };
+}
+//# sourceMappingURL=property.js.map

package/dist/src/entities/property.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"property.js","sourceRoot":"","sources":["../../../src/entities/property.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,UAAU,uBAAuB,CACrC,OAAgB,EAChB,QAAuB;IAEvB,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;QACtB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,iBAAiB,GAAQ,SAAS,CAAC;IACvC,QAAQ,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QAC9B,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS,CAAC;QACf,KAAK,QAAQ;YACX,iBAAiB,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC;YAC3C,MAAM;QACR;YACE,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,MAAM,QAAQ,GAAG,mBAAmB,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAE7D,IAAI,eAAe,GAAG,QAAQ,CAAC;IAC/B,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,YAAY;YACf,eAAe,GAAG,QAAQ,CAAC;YAC3B,MAAM;QACR,KAAK,sBAAsB;YACzB,eAAe,GAAG,QAAQ,CAAC;YAC3B,MAAM;QACR,KAAK,UAAU,CAAC;QAChB,KAAK,WAAW,CAAC;QACjB,KAAK,WAAW,CAAC;QACjB,KAAK,WAAW;YACd,eAAe,GAAG,KAAK,CAAC;YACxB,MAAM;QACR,KAAK,YAAY,CAAC;QAClB,KAAK,YAAY;YACf,eAAe,GAAG,QAAQ,CAAC;YAC3B,MAAM;QACR,KAAK,UAAU;YACb,eAAe,GAAG,MAAM,CAAC;YACzB,MAAM;QACR,KAAK,oBAAoB;YACvB,eAAe,GAAG,gBAAgB,CAAC;YACnC,MAAM;QACR,KAAK,aAAa;YAChB,eAAe,GAAG,SAAS,CAAC;YAC5B,MAAM;QACR,KAAK,YAAY;YACf,eAAe,GAAG,QAAQ,CAAC;YAC3B,MAAM;QACR,KAAK,UAAU;YACb,eAAe,GAAG,MAAM,CAAC;YACzB,MAAM;QACR,KAAK,cAAc,CAAC;QACpB,KAAK,eAAe,CAAC;QACrB;YACE,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,OAAO,EAAE,CAAC,eAAe,CAAC,EAAE,iBAAiB,EAAE,CAAC;AAClD,CAAC"}

package/dist/src/entities/revision-definition.d.ts

@@ -0,0 +1,10 @@
+import { Enum, EnumMember, Interface, Model, ModelProperty, Namespace, Operation, Program } from "@typespec/compiler";
+export interface RevisionDefinition {
+    Date: string;
+    Version: string;
+    Description?: string;
+    RemovalDate: string;
+    Category?: string;
+}
+export declare function GetRevisionDefinition(program: Program, type: Model | ModelProperty | EnumMember | Enum | Operation | Namespace | Interface, namespace: Namespace | undefined): RevisionDefinition | undefined;
+//# sourceMappingURL=revision-definition.d.ts.map

package/dist/src/entities/revision-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision-definition.d.ts","sourceRoot":"","sources":["../../../src/entities/revision-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAQ,MAAM,oBAAoB,CAAC;AAG5H,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,KAAK,GAAG,aAAa,GAAG,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,EACnF,SAAS,EAAE,SAAS,GAAG,SAAS,GAC/B,kBAAkB,GAAG,SAAS,CAiBhC"}

package/dist/src/entities/revision-definition.js

@@ -0,0 +1,53 @@
+import { getPrivatePreview, getDeprecatedDefinitions, getPrivatePreviewDefinitions, getGraphDeprecated } from "../index.js";
+export function GetRevisionDefinition(program, type, namespace) {
+    if (!namespace) {
+        return undefined;
+    }
+    const deprecated = getGraphDeprecated(program, type);
+    if (deprecated) {
+        return getRevisionDefinitionFromDeprecation(program, namespace, deprecated);
+    }
+    const privatePreview = getPrivatePreview(program, type)
+        || getPrivatePreviewFromNamespace(program, type)
+        || undefined;
+    return privatePreview
+        ? getRevisionDefinitionFromPrivatePreview(program, namespace, privatePreview)
+        : undefined;
+}
+function getPrivatePreviewFromNamespace(program, type) {
+    switch (type.kind) {
+        case 'Model':
+        case "Enum":
+        case "Interface":
+        case "Operation":
+            return getPrivatePreview(program, type.namespace);
+    }
+    return undefined;
+}
+function getRevisionDefinitionFromDeprecation(program, namespace, deprecated) {
+    const deprecatedDefinitions = getDeprecatedDefinitions(program, namespace);
+    const definition = deprecatedDefinitions.get(deprecated);
+    if (!definition) {
+        return undefined;
+    }
+    return {
+        Date: definition.announcementDate,
+        RemovalDate: definition.removalDate,
+        Version: `${definition.announcementDate.substring(0, 7)}/${definition.category}`,
+        Description: definition.description,
+        Category: definition.category,
+    };
+}
+function getRevisionDefinitionFromPrivatePreview(program, namespace, deprecated) {
+    const privatePreviewDefinitions = getPrivatePreviewDefinitions(program, namespace);
+    const definition = privatePreviewDefinitions.get(deprecated);
+    if (!definition) {
+        return undefined;
+    }
+    return {
+        Date: definition.announcementDate,
+        RemovalDate: definition.removalDate,
+        Version: `${definition.announcementDate.substring(0, 7)}/PrivatePreview:${definition.name}`,
+    };
+}
+//# sourceMappingURL=revision-definition.js.map

package/dist/src/entities/revision-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision-definition.js","sourceRoot":"","sources":["../../../src/entities/revision-definition.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,4BAA4B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAU5H,MAAM,UAAU,qBAAqB,CACnC,OAAgB,EAChB,IAAmF,EACnF,SAAgC;IAEhC,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,MAAM,UAAU,GAAG,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACrD,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,oCAAoC,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;IAC9E,CAAC;IAED,MAAM,cAAc,GAAG,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC;WAClD,8BAA8B,CAAC,OAAO,EAAE,IAAI,CAAC;WAC7C,SAAS,CAAC;IAEf,OAAO,cAAc;QACnB,CAAC,CAAC,uCAAuC,CAAC,OAAO,EAAE,SAAS,EAAE,cAAc,CAAC;QAC7E,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,SAAS,8BAA8B,CAAC,OAAgB,EAAE,IAAU;IAClE,QAAO,IAAI,CAAC,IAAI,EAAC,CAAC;QAChB,KAAK,OAAO,CAAC;QACb,KAAK,MAAM,CAAC;QACZ,KAAK,WAAW,CAAC;QACjB,KAAK,WAAW;YACd,OAAO,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,SAAiB,CAAC,CAAA;IAC7D,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,oCAAoC,CAC3C,OAAgB,EAChB,SAAoB,EACpB,UAAkB;IAElB,MAAM,qBAAqB,GAAG,wBAAwB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC3E,MAAM,UAAU,GAAG,qBAAqB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACzD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO;QACL,IAAI,EAAE,UAAU,CAAC,gBAAgB;QACjC,WAAW,EAAE,UAAU,CAAC,WAAW;QACnC,OAAO,EAAE,GAAG,UAAU,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,UAAU,CAAC,QAAQ,EAAE;QAChF,WAAW,EAAE,UAAU,CAAC,WAAW;QACnC,QAAQ,EAAE,UAAU,CAAC,QAAQ;KAC9B,CAAC;AACJ,CAAC;AAED,SAAS,uCAAuC,CAC9C,OAAgB,EAChB,SAAoB,EACpB,UAAkB;IAElB,MAAM,yBAAyB,GAAG,4BAA4B,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACnF,MAAM,UAAU,GAAG,yBAAyB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC7D,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO;QACL,IAAI,EAAE,UAAU,CAAC,gBAAgB;QACjC,WAAW,EAAE,UAAU,CAAC,WAAW;QACnC,OAAO,EAAE,GAAG,UAAU,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,mBAAmB,UAAU,CAAC,IAAI,EAAE;KAC5F,CAAC;AACJ,CAAC"}

package/dist/src/entities/term.d.ts

@@ -0,0 +1,8 @@
+import { Namespace, Program } from "@typespec/compiler";
+export interface MsGraphTerm {
+    Name: string;
+    Type: string;
+    Description: string;
+}
+export declare function GetMsGraphTerms(program: Program, namespace: Namespace): MsGraphTerm[];
+//# sourceMappingURL=term.d.ts.map

package/dist/src/entities/term.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"term.d.ts","sourceRoot":"","sources":["../../../src/entities/term.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAIxD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,WAAW,EAAE,CAYrF"}

package/dist/src/entities/term.js

@@ -0,0 +1,14 @@
+import { getTerms } from "../index.js";
+import { getNameForModelType } from "../utils.js";
+export function GetMsGraphTerms(program, namespace) {
+    const terms = new Array();
+    getTerms(program, namespace).forEach((term, _) => {
+        terms.push({
+            Name: term.name,
+            Type: getNameForModelType(program, term.type),
+            Description: term.description,
+        });
+    });
+    return terms;
+}
+//# sourceMappingURL=term.js.map

package/dist/src/entities/term.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"term.js","sourceRoot":"","sources":["../../../src/entities/term.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAQlD,MAAM,UAAU,eAAe,CAAC,OAAgB,EAAE,SAAoB;IACpE,MAAM,KAAK,GAAG,IAAI,KAAK,EAAe,CAAC;IAEvC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;QAC/C,KAAK,CAAC,IAAI,CAAC;YACT,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC;YAC7C,WAAW,EAAE,IAAI,CAAC,WAAW;SAC9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/src/index.d.ts

@@ -1,7 +1,5 @@
-export * from "./decorators/handlers/custom/index.js";
-export * from "./decorators/handlers/index.js";
-export * from "./decorators/has-stream.js";
 export * from "./decorators/index.js";
 export * from "./emitter.js";
+export * from "./validate.js";
 export * from "./linter.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}

package/dist/src/index.js

@@ -1,7 +1,5 @@
-export * from "./decorators/handlers/custom/index.js";
-export * from "./decorators/handlers/index.js";
-export * from "./decorators/has-stream.js";
 export * from "./decorators/index.js";
 export * from "./emitter.js";
+export * from "./validate.js";
 export * from "./linter.js";
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}

package/dist/src/lib.d.ts

@@ -1,138 +1,164 @@
-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 "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 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 "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 reportDiagnostic: <C extends "decorator-missing-dependencies" | "element-missing-dependencies" | "decorator-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 default: import("@typespec/compiler").CallableMessage<[string, string, string]>;
         readonly function: import("@typespec/compiler").CallableMessage<[]>;
     };
     "element-missing-dependencies": {
-        readonly default: import("@typespec/compiler").CallableMessage<["element", "other", "location"]>;
+        readonly default: import("@typespec/compiler").CallableMessage<[string, string, string]>;
         readonly operation: import("@typespec/compiler").CallableMessage<[]>;
+        readonly collectionNavigationPropertiesNotNullable: "Collection-valued navigation properties cannot be nullable.";
+        readonly propertyRequiredForCreate: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly modelMissingNamespace: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly operationParameterMismatch: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly topLevelNamespaceMissingPublicNamespace: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly propertyMissingContainsOrReferences: import("@typespec/compiler").CallableMessage<[string, string]>;
     };
     "decorator-invalid-use": {
-        readonly default: import("@typespec/compiler").CallableMessage<["decorator", "other", "location"]>;
+        readonly default: import("@typespec/compiler").CallableMessage<[string, string, string]>;
         readonly alternateKey: import("@typespec/compiler").CallableMessage<[]>;
-        readonly disallowedTypeSpecDecorators: import("@typespec/compiler").CallableMessage<["decorator"]>;
-        readonly expandProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
+        readonly disallowedTypeSpecDecorators: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly expandProperties: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly filterProperties: import("@typespec/compiler").CallableMessage<[string, string]>;
+        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 orderByProperties: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly required: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly wrongType: import("@typespec/compiler").CallableMessage<[string, string]>;
+        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<[string]>;
+        readonly invalidWorkloadNamespaceName: import("@typespec/compiler").CallableMessage<[string]>;
+        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 ownerlessInterfaceCannotHaveAnyOperations: 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<[string]>;
+        readonly referenceTargetInterfaceMustHaveGraphRoute: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referenceTargetMustOnlyBeUsedOnceOnInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referenceTargetPathShouldNotHaveParameters: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly interfaceWithGraphRouteMustExtendGraphStandardBaseInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly duplicateGraphRouteNotAllowed: import("@typespec/compiler").CallableMessage<[string, string, string]>;
+        readonly duplicateParametersAreNotAllowedInGraphRoute: import("@typespec/compiler").CallableMessage<[string, string]>;
+        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<[string]>;
+        readonly entityAndComplexAreMutuallyExclusive: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly filterPropertiesShouldBeSimple: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly navigationPropertyShouldBeTargettedWithOneInterface: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly graphRouteMustMatchModelStructure: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly overloadedFunctionReturnTypesMustBeSame: import("@typespec/compiler").CallableMessage<[string, string]>;
     };
     "singleton-invalid-name": {
-        readonly default: import("@typespec/compiler").CallableMessage<["value"]>;
+        readonly default: import("@typespec/compiler").CallableMessage<[string]>;
     };
     "extends-invalid-use": {
-        readonly default: import("@typespec/compiler").CallableMessage<["type", "type"]>;
+        readonly default: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly namespaces: "A model can only extend other models in a different logical namespace. Use @partial 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<[]>;
-    };
-    "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 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"]>;
-    };
-    "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<[string]>;
+        readonly recordTypeCannotBePrepopulated: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly recordTypeCannotBeNull: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly recordTypeCannotBeUsedInLine: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly interfaceWithPartialBindingType: import("@typespec/compiler").CallableMessage<[string, string]>;
     };
 }[C]>(program: import("@typespec/compiler").Program, diag: import("@typespec/compiler").DiagnosticReport<{
     "decorator-missing-dependencies": {
-        readonly default: import("@typespec/compiler").CallableMessage<["decorator", "required", "location"]>;
+        readonly default: import("@typespec/compiler").CallableMessage<[string, string, string]>;
         readonly function: import("@typespec/compiler").CallableMessage<[]>;
     };
     "element-missing-dependencies": {
-        readonly default: import("@typespec/compiler").CallableMessage<["element", "other", "location"]>;
+        readonly default: import("@typespec/compiler").CallableMessage<[string, string, string]>;
         readonly operation: import("@typespec/compiler").CallableMessage<[]>;
+        readonly collectionNavigationPropertiesNotNullable: "Collection-valued navigation properties cannot be nullable.";
+        readonly propertyRequiredForCreate: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly modelMissingNamespace: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly operationParameterMismatch: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly topLevelNamespaceMissingPublicNamespace: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly propertyMissingContainsOrReferences: import("@typespec/compiler").CallableMessage<[string, string]>;
     };
     "decorator-invalid-use": {
-        readonly default: import("@typespec/compiler").CallableMessage<["decorator", "other", "location"]>;
+        readonly default: import("@typespec/compiler").CallableMessage<[string, string, string]>;
         readonly alternateKey: import("@typespec/compiler").CallableMessage<[]>;
-        readonly disallowedTypeSpecDecorators: import("@typespec/compiler").CallableMessage<["decorator"]>;
-        readonly expandProperties: import("@typespec/compiler").CallableMessage<["properties", "model"]>;
+        readonly disallowedTypeSpecDecorators: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly expandProperties: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly filterProperties: import("@typespec/compiler").CallableMessage<[string, string]>;
+        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 orderByProperties: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly required: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly wrongType: import("@typespec/compiler").CallableMessage<[string, string]>;
+        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<[string]>;
+        readonly invalidWorkloadNamespaceName: import("@typespec/compiler").CallableMessage<[string]>;
+        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 ownerlessInterfaceCannotHaveAnyOperations: 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<[string]>;
+        readonly referenceTargetInterfaceMustHaveGraphRoute: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referenceTargetMustOnlyBeUsedOnceOnInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly referenceTargetPathShouldNotHaveParameters: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly interfaceWithGraphRouteMustExtendGraphStandardBaseInterface: import("@typespec/compiler").CallableMessage<[]>;
+        readonly duplicateGraphRouteNotAllowed: import("@typespec/compiler").CallableMessage<[string, string, string]>;
+        readonly duplicateParametersAreNotAllowedInGraphRoute: import("@typespec/compiler").CallableMessage<[string, string]>;
+        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<[string]>;
+        readonly entityAndComplexAreMutuallyExclusive: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly filterPropertiesShouldBeSimple: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly navigationPropertyShouldBeTargettedWithOneInterface: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly graphRouteMustMatchModelStructure: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly overloadedFunctionReturnTypesMustBeSame: import("@typespec/compiler").CallableMessage<[string, string]>;
     };
     "singleton-invalid-name": {
-        readonly default: import("@typespec/compiler").CallableMessage<["value"]>;
+        readonly default: import("@typespec/compiler").CallableMessage<[string]>;
     };
     "extends-invalid-use": {
-        readonly default: import("@typespec/compiler").CallableMessage<["type", "type"]>;
-    };
-    "use-evolvable-enum": {
-        readonly default: import("@typespec/compiler").CallableMessage<["enum"]>;
+        readonly default: import("@typespec/compiler").CallableMessage<[string, string]>;
+        readonly namespaces: "A model can only extend other models in a different logical namespace. Use @partial instead.";
+    };
+    "type-invalid-use": {
+        readonly default: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly recordTypeCannotBePrepopulated: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly recordTypeCannotBeNull: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly recordTypeCannotBeUsedInLine: import("@typespec/compiler").CallableMessage<[string]>;
+        readonly interfaceWithPartialBindingType: import("@typespec/compiler").CallableMessage<[string, string]>;
     };
 }, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDT,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,MAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqGpB,CAAC"}

package/dist/src/lib.js

@@ -1,6 +1,18 @@
 import { createTypeSpecLibrary, paramMessage } from "@typespec/compiler";
-export const namespace = "TypeSpec.MsGraph";
-export const libDef = {
+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 { reportDiagnostic } = createTypeSpecLibrary({
     name: "@microsoft/typespec-msgraph",
     diagnostics: {
         "decorator-missing-dependencies": {
@@ -15,6 +27,12 @@ export const libDef = {
             messages: {
                 default: paramMessage `The ${"element"} must be used together with ${"other"} on a ${"location"}.`,
                 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.`,
             },
         },
         "decorator-invalid-use": {
@@ -24,10 +42,50 @@ export const libDef = {
                 alternateKey: paramMessage `The @alternateKey decorator can only be attached to a non-nullable primitive-typed property.`,
                 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 @partial 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.`,
+                ownerlessInterfaceCannotHaveAnyOperations: paramMessage `The @ownerless decorator can only be applied to interfaces without any 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 @referenceTarget 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"}" must have unique names.`,
+                complexCannotBeDecoratedWithPartial: paramMessage `A @complex type cannot be a @partial.`,
+                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 @entity 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.`,
             },
         },
         "singleton-invalid-name": {
@@ -40,16 +98,20 @@ 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 @partial 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.`,
+            }
+        }
     },
-};
-export const $lib = createTypeSpecLibrary(libDef);
-export const { reportDiagnostic } = $lib;
+    emitter: { options: EmitterOptionsSchema },
+});
 //# sourceMappingURL=lib.js.map