@typespec/versioning 0.41.0

package/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/README.md

@@ -0,0 +1,233 @@
+# `@typespec/versioning` library
+
+This package provide [TypeSpec](https://github.com/microsoft/typespec) decorators and projections to define versioning in a service.
+
+## Install
+
+Run the following command in your typespec project root directory.
+
+```bash
+npm install @typespec/versioning
+```
+
+## Usage
+
+```typespec
+import "@typespec/versioning";
+
+using Versioning;
+```
+
+### Enable versioning for Service or Library
+
+Use [`@versioned`](#versioned) decorator to mark a namespace as versioned.
+
+```typespec
+@versioned(Versions)
+namespace MyService;
+
+enum Versions {
+  v1,
+  v2,
+  v3,
+}
+```
+
+The following decorators can then be used to provide version evolution of a service.
+
+- [`@added`](#added)
+- [`@removed`](#removed)
+- [`@renamedFrom`](#renamedfrom)
+- [`@madeOptional`](#madeoptional)
+
+### Consume a versioned library
+
+When consuming a versioned library, it is required to indicate which version of the library to use.
+See [`@versionedDependency`](#versioneddependency) decorator for information about this.
+
+## References
+
+Decorators:
+
+- [`@versioned`](#versioned) <!-- no toc -->
+- [`@useDependency`](#usedependency)
+- [`@added`](#added)
+- [`@removed`](#removed)
+- [`@renamedFrom`](#renamedfrom)
+- [`@madeOptional`](#madeoptional)
+
+### `@versioned`
+
+Mark a namespace as being versioned. It takes as an argument an `enum` of versions for that namespace.
+
+```typespec
+@versioned(Versions)
+namespace MyService;
+
+enum Versions {
+  v1,
+  v2,
+  v3,
+}
+```
+
+### `@useDependency`
+
+When using elements from another versioned namespace, the consuming namespace **MUST** specify which version of the consumed namespace to use even if the consuming namespace is not versioned itself.
+
+The decorator can either target:
+
+- an unversioned namespace.
+- individual enum members of a versioned namespace's version enum.
+
+If we have a library with the following definition:
+
+```typespec
+@versioned(Versions)
+namespace MyLib;
+
+enum Versions {
+  v1,
+  v1_1,
+  v2,
+}
+```
+
+Pick a specific version to be used for all version of the service.
+
+```typespec
+@versioned(Versions)
+@useDependency(MyLib.Versions.v1_1)
+namespace MyService1;
+
+enum Version {
+  v1,
+  v2,
+  v3,
+}
+```
+
+Service is not versioned, pick which version of `MyLib` should be used.
+
+```typespec
+@useDependency(MyLib.Versions.v1_1)
+namespace NonVersionedService;
+```
+
+Select mapping of version to use
+
+```typespec
+@versioned(Versions)
+namespace MyService1;
+
+enum Version {
+  @useDependency(MyLib.Versions.v1_1) // V1 use lib v1_1
+  v1,
+  @useDependency(MyLib.Versions.v1_1) // V2 use lib v1_1
+  v2,
+  @useDependency(MyLib.Versions.v2) // V3 use lib v2
+  v3,
+}
+```
+
+### `@added`
+
+Specify which version an entity was added. Take the enum version member.
+
+Version enum member **MUST** be from the version enum for the containing namespace.
+
+```typespec
+@added(Versions.v2)
+op addedInV2(): void;
+
+@added(Versions.v2)
+model AlsoAddedInV2 {}
+
+model Foo {
+  name: string;
+
+  @added(Versions.v3)
+  addedInV3: string;
+}
+```
+
+### `@removed`
+
+Specify which version an entity was removed. Take the enum version member.
+
+Version enum member **MUST** be from the version enum for the containing namespace.
+
+```typespec
+@removed(Versions.v2)
+op removedInV2(): void;
+
+@removed(Versions.v2)
+model AlsoRemovedInV2 {}
+
+model Foo {
+  name: string;
+
+  @removed(Versions.v3)
+  removedInV3: string;
+}
+```
+
+### `@renamedFrom`
+
+Specify which version an entity was renamed and what is is old name.
+
+Version enum member **MUST** be from the version enum for the containing namespace.
+
+```typespec
+@renamedFrom(Versions.v2, "oldName")
+op newName(): void;
+```
+
+### `@madeOptional`
+
+Specify which version a property was made optional
+
+Version enum member **MUST** be from the version enum for the containing namespace.
+
+```typespec
+model Foo {
+  name: string;
+
+  @madeOptional(Versions.v2)
+  nickname: string;
+}
+```
+
+## Consuming versioning library from an emitter
+
+### Get the service representation at a given version
+
+Versioning library works with projection to project the service at a given version.
+
+```ts
+// Get a list of all the different version of the service and the projections
+const projections = buildVersionProjections(program, serviceNamespace);
+
+for (const projection of projections) {
+  const projectedProgram = projectProgram(program, projection.projections);
+  // projectedProgram now contains the representation of the service at the given version.
+}
+```
+
+### Get list of versions and version dependency across namespaces
+
+Versioning library works with projection to project the service at a given version.
+
+```ts
+const versions = resolveVersions(program, serviceNamespace);
+// versions now contain a list of all the version of the service namespace and what version should all the other dependencies namespace use.
+```
+
+### Consume versioning manually
+
+If the emitter needs to have the whole picture of the service evolution across the version then using the decorator accessor will provide the metadata for each type:
+
+- `getAddedOn`
+- `getRemovedOn`
+- `getRenamedFromVersion`
+- `getMadeOptionalOn`

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./validate.js";
+export * from "./versioning.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,3 @@
+export * from "./validate.js";
+export * from "./versioning.js";
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/dist/src/lib.d.ts

@@ -0,0 +1,82 @@
+export declare const reportDiagnostic: <C extends "versioned-dependency-tuple" | "versioned-dependency-tuple-enum-member" | "versioned-dependency-same-namespace" | "versioned-dependency-record-not-mapping" | "versioned-dependency-not-picked" | "version-not-found" | "using-versioned-library" | "invalid-renamed-from-value" | "incompatible-versioned-reference" | "incompatible-versioned-namespace-use-dependency" | "made-optional-not-optional", M extends keyof {
+    "versioned-dependency-tuple": {
+        readonly default: "Versioned dependency mapping must be a tuple [SourceVersion, TargetVersion].";
+    };
+    "versioned-dependency-tuple-enum-member": {
+        readonly default: "Versioned dependency mapping must be between enum members.";
+    };
+    "versioned-dependency-same-namespace": {
+        readonly default: "Versioned dependency mapping must all point to the same namespace but 2 versions have different namespaces 'namespace1' and 'namespace2'.";
+    };
+    "versioned-dependency-record-not-mapping": {
+        readonly default: import("@typespec/compiler").CallableMessage<["dependency"]>;
+    };
+    "versioned-dependency-not-picked": {
+        readonly default: import("@typespec/compiler").CallableMessage<["dependency"]>;
+    };
+    "version-not-found": {
+        readonly default: import("@typespec/compiler").CallableMessage<["version", "enumName", "enumName"]>;
+    };
+    "using-versioned-library": {
+        readonly default: import("@typespec/compiler").CallableMessage<["sourceNs", "targetNs"]>;
+    };
+    "invalid-renamed-from-value": {
+        readonly default: "@renamedFrom.oldName cannot be empty string.";
+    };
+    "incompatible-versioned-reference": {
+        readonly default: import("@typespec/compiler").CallableMessage<["sourceName", "targetName"]>;
+        readonly addedAfter: import("@typespec/compiler").CallableMessage<["sourceName", "sourceAddedOn", "targetName", "targetAddedOn"]>;
+        readonly dependentAddedAfter: import("@typespec/compiler").CallableMessage<["sourceName", "sourceAddedOn", "targetName", "targetAddedOn"]>;
+        readonly removedBefore: import("@typespec/compiler").CallableMessage<["sourceName", "sourceRemovedOn", "targetName", "targetRemovedOn"]>;
+        readonly dependentRemovedBefore: import("@typespec/compiler").CallableMessage<["sourceName", "sourceRemovedOn", "targetName", "targetRemovedOn"]>;
+        readonly versionedDependencyAddedAfter: import("@typespec/compiler").CallableMessage<["sourceName", "targetName", "targetAddedOn", "dependencyVersion"]>;
+        readonly versionedDependencyRemovedBefore: import("@typespec/compiler").CallableMessage<["sourceName", "targetName", "targetAddedOn", "dependencyVersion"]>;
+    };
+    "incompatible-versioned-namespace-use-dependency": {
+        readonly default: "The useDependency decorator can only be used on a Namespace if the namespace is unversioned. For versioned namespaces, put the useDependency decorator on the version enum members.";
+    };
+    "made-optional-not-optional": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name", "name"]>;
+    };
+}[C]>(program: import("@typespec/compiler").Program, diag: import("@typespec/compiler").DiagnosticReport<{
+    "versioned-dependency-tuple": {
+        readonly default: "Versioned dependency mapping must be a tuple [SourceVersion, TargetVersion].";
+    };
+    "versioned-dependency-tuple-enum-member": {
+        readonly default: "Versioned dependency mapping must be between enum members.";
+    };
+    "versioned-dependency-same-namespace": {
+        readonly default: "Versioned dependency mapping must all point to the same namespace but 2 versions have different namespaces 'namespace1' and 'namespace2'.";
+    };
+    "versioned-dependency-record-not-mapping": {
+        readonly default: import("@typespec/compiler").CallableMessage<["dependency"]>;
+    };
+    "versioned-dependency-not-picked": {
+        readonly default: import("@typespec/compiler").CallableMessage<["dependency"]>;
+    };
+    "version-not-found": {
+        readonly default: import("@typespec/compiler").CallableMessage<["version", "enumName", "enumName"]>;
+    };
+    "using-versioned-library": {
+        readonly default: import("@typespec/compiler").CallableMessage<["sourceNs", "targetNs"]>;
+    };
+    "invalid-renamed-from-value": {
+        readonly default: "@renamedFrom.oldName cannot be empty string.";
+    };
+    "incompatible-versioned-reference": {
+        readonly default: import("@typespec/compiler").CallableMessage<["sourceName", "targetName"]>;
+        readonly addedAfter: import("@typespec/compiler").CallableMessage<["sourceName", "sourceAddedOn", "targetName", "targetAddedOn"]>;
+        readonly dependentAddedAfter: import("@typespec/compiler").CallableMessage<["sourceName", "sourceAddedOn", "targetName", "targetAddedOn"]>;
+        readonly removedBefore: import("@typespec/compiler").CallableMessage<["sourceName", "sourceRemovedOn", "targetName", "targetRemovedOn"]>;
+        readonly dependentRemovedBefore: import("@typespec/compiler").CallableMessage<["sourceName", "sourceRemovedOn", "targetName", "targetRemovedOn"]>;
+        readonly versionedDependencyAddedAfter: import("@typespec/compiler").CallableMessage<["sourceName", "targetName", "targetAddedOn", "dependencyVersion"]>;
+        readonly versionedDependencyRemovedBefore: import("@typespec/compiler").CallableMessage<["sourceName", "targetName", "targetAddedOn", "dependencyVersion"]>;
+    };
+    "incompatible-versioned-namespace-use-dependency": {
+        readonly default: "The useDependency decorator can only be used on a Namespace if the namespace is unversioned. For versioned namespaces, put the useDependency decorator on the version enum members.";
+    };
+    "made-optional-not-optional": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name", "name"]>;
+    };
+}, C, M>) => void, createStateSymbol: (name: string) => symbol;
+//# sourceMappingURL=lib.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/lib.ts"],"names":[],"mappings":"AAgFA,eAAO,MAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAE,iBAAiB,0BAAkC,CAAC"}

package/dist/src/lib.js

@@ -0,0 +1,80 @@
+import { createTypeSpecLibrary, paramMessage } from "@typespec/compiler";
+const libDef = {
+    name: "@typespec/versioning",
+    diagnostics: {
+        "versioned-dependency-tuple": {
+            severity: "error",
+            messages: {
+                default: `Versioned dependency mapping must be a tuple [SourceVersion, TargetVersion].`,
+            },
+        },
+        "versioned-dependency-tuple-enum-member": {
+            severity: "error",
+            messages: {
+                default: `Versioned dependency mapping must be between enum members.`,
+            },
+        },
+        "versioned-dependency-same-namespace": {
+            severity: "error",
+            messages: {
+                default: `Versioned dependency mapping must all point to the same namespace but 2 versions have different namespaces '${"namespace1"}' and '${"namespace2"}'.`,
+            },
+        },
+        "versioned-dependency-record-not-mapping": {
+            severity: "error",
+            messages: {
+                default: paramMessage `The versionedDependency decorator must provide a model mapping local versions to dependency '${"dependency"}' versions`,
+            },
+        },
+        "versioned-dependency-not-picked": {
+            severity: "error",
+            messages: {
+                default: paramMessage `The versionedDependency decorator must provide a version of the dependency '${"dependency"}'.`,
+            },
+        },
+        "version-not-found": {
+            severity: "error",
+            messages: {
+                default: paramMessage `The provided version '${"version"}' from '${"enumName"}' is not declared as a version enum. Use '@versioned(${"enumName"})' on the containing namespace.`,
+            },
+        },
+        "using-versioned-library": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Namespace '${"sourceNs"}' is referencing types from versioned namespace '${"targetNs"}' but didn't specify which versions with @useDependency.`,
+            },
+        },
+        "invalid-renamed-from-value": {
+            severity: "error",
+            messages: {
+                default: "@renamedFrom.oldName cannot be empty string.",
+            },
+        },
+        "incompatible-versioned-reference": {
+            severity: "error",
+            messages: {
+                default: paramMessage `'${"sourceName"}' is referencing versioned type '${"targetName"}' but is not versioned itself.`,
+                addedAfter: paramMessage `'${"sourceName"}' was added on version '${"sourceAddedOn"}' but referencing type '${"targetName"}' added in version '${"targetAddedOn"}'.`,
+                dependentAddedAfter: paramMessage `'${"sourceName"}' was added on version '${"sourceAddedOn"}' but contains type '${"targetName"}' added in version '${"targetAddedOn"}'.`,
+                removedBefore: paramMessage `'${"sourceName"}' was removed on version '${"sourceRemovedOn"}' but referencing type '${"targetName"}' removed in version '${"targetRemovedOn"}'.`,
+                dependentRemovedBefore: paramMessage `'${"sourceName"}' was removed on version '${"sourceRemovedOn"}' but contains type '${"targetName"}' removed in version '${"targetRemovedOn"}'.`,
+                versionedDependencyAddedAfter: paramMessage `'${"sourceName"}' is referencing type '${"targetName"}' added in version '${"targetAddedOn"}' but version used is ${"dependencyVersion"}.`,
+                versionedDependencyRemovedBefore: paramMessage `'${"sourceName"}' is referencing type '${"targetName"}' removed in version '${"targetAddedOn"}' but version used is ${"dependencyVersion"}.`,
+            },
+        },
+        "incompatible-versioned-namespace-use-dependency": {
+            severity: "error",
+            messages: {
+                default: "The useDependency decorator can only be used on a Namespace if the namespace is unversioned. For versioned namespaces, put the useDependency decorator on the version enum members.",
+            },
+        },
+        "made-optional-not-optional": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Property '${"name"}' marked with @madeOptional but is required. Should be '${"name"}?'`,
+            },
+        },
+    },
+};
+export const { reportDiagnostic, createStateSymbol } = createTypeSpecLibrary(libDef);
+//# sourceMappingURL=lib.js.map

package/dist/src/lib.js.map

@@ -0,0 +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,MAAM,GAAG;IACb,IAAI,EAAE,sBAAsB;IAC5B,WAAW,EAAE;QACX,4BAA4B,EAAE;YAC5B,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,8EAA8E;aACxF;SACF;QACD,wCAAwC,EAAE;YACxC,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,4DAA4D;aACtE;SACF;QACD,qCAAqC,EAAE;YACrC,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,+GAA+G,YAAY,UAAU,YAAY,IAAI;aAC/J;SACF;QACD,yCAAyC,EAAE;YACzC,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,gGAAgG,YAAY,YAAY;aAC9I;SACF;QACD,iCAAiC,EAAE;YACjC,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,+EAA+E,YAAY,IAAI;aACrH;SACF;QACD,mBAAmB,EAAE;YACnB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,yBAAyB,SAAS,WAAW,UAAU,wDAAwD,UAAU,iCAAiC;aAChL;SACF;QACD,yBAAyB,EAAE;YACzB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,cAAc,UAAU,oDAAoD,UAAU,0DAA0D;aACtK;SACF;QACD,4BAA4B,EAAE;YAC5B,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,8CAA8C;aACxD;SACF;QACD,kCAAkC,EAAE;YAClC,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,IAAI,YAAY,oCAAoC,YAAY,gCAAgC;gBACrH,UAAU,EAAE,YAAY,CAAA,IAAI,YAAY,2BAA2B,eAAe,2BAA2B,YAAY,uBAAuB,eAAe,IAAI;gBACnK,mBAAmB,EAAE,YAAY,CAAA,IAAI,YAAY,2BAA2B,eAAe,wBAAwB,YAAY,uBAAuB,eAAe,IAAI;gBACzK,aAAa,EAAE,YAAY,CAAA,IAAI,YAAY,6BAA6B,iBAAiB,2BAA2B,YAAY,yBAAyB,iBAAiB,IAAI;gBAC9K,sBAAsB,EAAE,YAAY,CAAA,IAAI,YAAY,6BAA6B,iBAAiB,wBAAwB,YAAY,yBAAyB,iBAAiB,IAAI;gBACpL,6BAA6B,EAAE,YAAY,CAAA,IAAI,YAAY,0BAA0B,YAAY,uBAAuB,eAAe,yBAAyB,mBAAmB,GAAG;gBACtL,gCAAgC,EAAE,YAAY,CAAA,IAAI,YAAY,0BAA0B,YAAY,yBAAyB,eAAe,yBAAyB,mBAAmB,GAAG;aAC5L;SACF;QACD,iDAAiD,EAAE;YACjD,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EACL,qLAAqL;aACxL;SACF;QACD,4BAA4B,EAAE;YAC5B,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,aAAa,MAAM,2DAA2D,MAAM,IAAI;aAC9G;SACF;KACF;CACO,CAAC;AACX,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC"}

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

@@ -0,0 +1,3 @@
+import { TypeSpecTestLibrary } from "@typespec/compiler/testing";
+export declare const VersioningTestLibrary: TypeSpecTestLibrary;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGpF,eAAO,MAAM,qBAAqB,EAAE,mBAGlC,CAAC"}

package/dist/src/testing/index.js

@@ -0,0 +1,8 @@
+import { resolvePath } from "@typespec/compiler";
+import { createTestLibrary } from "@typespec/compiler/testing";
+import { fileURLToPath } from "url";
+export const VersioningTestLibrary = createTestLibrary({
+    name: "@typespec/versioning",
+    packageRoot: resolvePath(fileURLToPath(import.meta.url), "../../../../"),
+});
+//# sourceMappingURL=index.js.map

package/dist/src/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAuB,MAAM,4BAA4B,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AAEpC,MAAM,CAAC,MAAM,qBAAqB,GAAwB,iBAAiB,CAAC;IAC1E,IAAI,EAAE,sBAAsB;IAC5B,WAAW,EAAE,WAAW,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,cAAc,CAAC;CACzE,CAAC,CAAC"}

package/dist/src/validate.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,OAAO,EAER,MAAM,oBAAoB,CAAC;AAa5B,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,QA+G3C"}