@typespec/openapi3 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,124 @@
+# TypeSpec OpenAPI 3.0 Emitter
+
+This package provides the [TypeSpec](https://github.com/microsoft/typespec) emitter to produce OpenAPI 3.0 output from TypeSpec source.
+
+## Install
+
+In your typespec project root
+
+```bash
+npm install @typespec/openapi3
+```
+
+## Emit OpenAPI 3.0 spec
+
+1. Via the command line
+
+```bash
+tsp compile . --emit @typespec/openapi3
+```
+
+2. Via the config
+
+Add the following to the `tspconfig.yaml` file.
+
+```yaml
+emitters:
+  @typespec/openapi3: true
+```
+
+For configuration [see options](#emitter-options)
+
+## Use OpenAPI 3.0 specific decorators:
+
+```typespec
+import "@typespec/openapi3";
+
+using OpenAPI;
+
+// Using `using`
+@useRef("common.json#/components/schemas/Foo")
+model Foo {}
+
+// Using fully qualified names
+@OpenAPI.oneOf
+union MyUnion {
+  cat: Cat,
+  dog: Dog,
+}
+```
+
+## Decorators
+
+- [@useRef](#useref)
+- [@oneOf](#oneof)
+
+### @useRef
+
+Syntax:
+
+```
+@useRef(urlString)
+```
+
+`@useRef`
+
+`@useRef` is used to replace the TypeSpec model type in emitter output with a pre-existing named OpenAPI schema.
+
+### @oneOf
+
+Syntax:
+
+```
+@oneOf()
+```
+
+`@oneOf`emits `oneOf` keyword for a union type in the resulting OpenAPI 3.0 specification. It indicates that the value of union type can only contain exactly one of the subschemas.
+
+`@oneOf` can only be applied to a union types.
+
+## Emitter options:
+
+Emitter options can be configured via the `tspconfig.yaml` configuration:
+
+```yaml
+emitters:
+  '@typespec/openapi3':
+    <optionName>: <value>
+
+
+# For example
+emitters:
+  '@typespec/openapi3':
+    outputFile: my-custom-openapi.json
+```
+
+or via the command line with
+
+```bash
+--option "@typespec/openapi3.<optionName>=<value>"
+
+# For example
+--option "@typespec/openapi3.output-file=my-custom-openapi.json"
+```
+
+### `output-file`
+
+Configure the name of the swagger output file relative to the compiler `output-path`.
+
+### `new-line`
+
+Set the newline character for emitting files. Can be either:
+
+- `lf`(Default)
+- `crlf`
+
+### `omit-unreachable-types`
+
+Only include types referenced via an operation.
+
+## See also
+
+- [TypeSpec Getting Started](https://github.com/microsoft/typespec#getting-started)
+- [TypeSpec Website](https://microsoft.github.io/typespec)
+- [TypeSpec for the OpenAPI Developer](https://github.com/microsoft/typespec/blob/main/docs/typespec-for-openapi-dev.md)

package/dist/src/decorators.d.ts

@@ -0,0 +1,6 @@
+import { DecoratorContext, Program, Type } from "@typespec/compiler";
+export declare function $useRef(context: DecoratorContext, entity: Type, refUrl: string): void;
+export declare function getRef(program: Program, entity: Type): string | undefined;
+export declare function $oneOf(context: DecoratorContext, entity: Type): void;
+export declare function getOneOf(program: Program, entity: Type): boolean;
+//# sourceMappingURL=decorators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,IAAI,EAA2B,MAAM,oBAAoB,CAAC;AAI9F,wBAAgB,OAAO,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAMrF;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAEzE;AAGD,wBAAgB,MAAM,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,IAAI,QAK7D;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO,CAEhE"}

package/dist/src/decorators.js

@@ -0,0 +1,23 @@
+import { validateDecoratorTarget } from "@typespec/compiler";
+import { createStateSymbol } from "./lib.js";
+const refTargetsKey = createStateSymbol("refs");
+export function $useRef(context, entity, refUrl) {
+    if (!validateDecoratorTarget(context, entity, "@useRef", ["Model", "ModelProperty"])) {
+        return;
+    }
+    context.program.stateMap(refTargetsKey).set(entity, refUrl);
+}
+export function getRef(program, entity) {
+    return program.stateMap(refTargetsKey).get(entity);
+}
+const oneOfKey = createStateSymbol("oneOf");
+export function $oneOf(context, entity) {
+    if (!validateDecoratorTarget(context, entity, "@oneOf", "Union")) {
+        return;
+    }
+    context.program.stateMap(oneOfKey).set(entity, true);
+}
+export function getOneOf(program, entity) {
+    return program.stateMap(oneOfKey).get(entity);
+}
+//# sourceMappingURL=decorators.js.map

package/dist/src/decorators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC9F,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,aAAa,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAChD,MAAM,UAAU,OAAO,CAAC,OAAyB,EAAE,MAAY,EAAE,MAAc;IAC7E,IAAI,CAAC,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,EAAE;QACpF,OAAO;KACR;IAED,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAC9D,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,OAAgB,EAAE,MAAY;IACnD,OAAO,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,QAAQ,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;AAC5C,MAAM,UAAU,MAAM,CAAC,OAAyB,EAAE,MAAY;IAC5D,IAAI,CAAC,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE;QAChE,OAAO;KACR;IACD,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,OAAgB,EAAE,MAAY;IACrD,OAAO,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AAChD,CAAC"}

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export declare const namespace = "OpenAPI";
+export * from "./decorators.js";
+export { $lib } from "./lib.js";
+export * from "./openapi.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,eAAO,MAAM,SAAS,YAAY,CAAC;AAEnC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAChC,cAAc,cAAc,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,5 @@
+export const namespace = "OpenAPI";
+export * from "./decorators.js";
+export { $lib } from "./lib.js";
+export * from "./openapi.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,MAAM,CAAC,MAAM,SAAS,GAAG,SAAS,CAAC;AAEnC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAChC,cAAc,cAAc,CAAC"}

package/dist/src/lib.d.ts

@@ -0,0 +1,216 @@
+import { JSONSchemaType } from "@typespec/compiler";
+export type FileType = "yaml" | "json";
+export interface OpenAPI3EmitterOptions {
+    /**
+     * If the content should be serialized as YAML or JSON.
+     * @default yaml, it not specified infer from the `output-file` extension
+     */
+    "file-type"?: FileType;
+    /**
+     * Name of the output file.
+     * @default `openapi.yaml` or `openapi.json` if {@link OpenAPI3EmitterOptions["file-type"]} is `"json"`
+     */
+    "output-file"?: string;
+    /**
+     * Set the newline character for emitting files.
+     * @default lf
+     */
+    "new-line"?: "crlf" | "lf";
+    /**
+     * Omit unreachable types.
+     * By default all types declared under the service namespace will be included. With this flag on only types references in an operation will be emitted.
+     */
+    "omit-unreachable-types"?: boolean;
+}
+export declare const libDef: {
+    readonly name: "@typespec/openapi3";
+    readonly diagnostics: {
+        readonly "invalid-server-variable": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: import("@typespec/compiler").CallableMessage<["propName"]>;
+            };
+        };
+        readonly "resource-namespace": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: "Resource goes on namespace";
+            };
+        };
+        readonly "path-query": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: "OpenAPI does not allow paths containing a query string.";
+            };
+        };
+        readonly "duplicate-body": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: "Duplicate @body declarations on response type";
+            };
+        };
+        readonly "duplicate-header": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: import("@typespec/compiler").CallableMessage<["header"]>;
+            };
+        };
+        readonly "status-code-in-default-response": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: "a default response should not have an explicit status code";
+            };
+        };
+        readonly "invalid-schema": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+            };
+        };
+        readonly "union-null": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: "Cannot have a union containing only null types.";
+            };
+        };
+        readonly "union-unsupported": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: "Unions are not supported unless all options are literals of the same type.";
+                readonly type: import("@typespec/compiler").CallableMessage<["kind"]>;
+                readonly empty: "Empty unions are not supported for OpenAPI v3 - enums must have at least one value.";
+                readonly null: "Unions containing multiple model types cannot be emitted to OpenAPI v2 unless the union is between one model type and 'null'.";
+            };
+        };
+        readonly "invalid-default": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+            };
+        };
+        readonly "inline-cycle": {
+            readonly severity: "error";
+            readonly messages: {
+                readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+            };
+        };
+    };
+    readonly emitter: {
+        readonly options: JSONSchemaType<OpenAPI3EmitterOptions>;
+    };
+};
+export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
+    "invalid-server-variable": {
+        readonly default: import("@typespec/compiler").CallableMessage<["propName"]>;
+    };
+    "resource-namespace": {
+        readonly default: "Resource goes on namespace";
+    };
+    "path-query": {
+        readonly default: "OpenAPI does not allow paths containing a query string.";
+    };
+    "duplicate-body": {
+        readonly default: "Duplicate @body declarations on response type";
+    };
+    "duplicate-header": {
+        readonly default: import("@typespec/compiler").CallableMessage<["header"]>;
+    };
+    "status-code-in-default-response": {
+        readonly default: "a default response should not have an explicit status code";
+    };
+    "invalid-schema": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+    };
+    "union-null": {
+        readonly default: "Cannot have a union containing only null types.";
+    };
+    "union-unsupported": {
+        readonly default: "Unions are not supported unless all options are literals of the same type.";
+        readonly type: import("@typespec/compiler").CallableMessage<["kind"]>;
+        readonly empty: "Empty unions are not supported for OpenAPI v3 - enums must have at least one value.";
+        readonly null: "Unions containing multiple model types cannot be emitted to OpenAPI v2 unless the union is between one model type and 'null'.";
+    };
+    "invalid-default": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+    };
+    "inline-cycle": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+    };
+}, OpenAPI3EmitterOptions>;
+export declare const reportDiagnostic: <C extends "invalid-server-variable" | "resource-namespace" | "path-query" | "duplicate-body" | "duplicate-header" | "status-code-in-default-response" | "invalid-schema" | "union-null" | "union-unsupported" | "invalid-default" | "inline-cycle", M extends keyof {
+    "invalid-server-variable": {
+        readonly default: import("@typespec/compiler").CallableMessage<["propName"]>;
+    };
+    "resource-namespace": {
+        readonly default: "Resource goes on namespace";
+    };
+    "path-query": {
+        readonly default: "OpenAPI does not allow paths containing a query string.";
+    };
+    "duplicate-body": {
+        readonly default: "Duplicate @body declarations on response type";
+    };
+    "duplicate-header": {
+        readonly default: import("@typespec/compiler").CallableMessage<["header"]>;
+    };
+    "status-code-in-default-response": {
+        readonly default: "a default response should not have an explicit status code";
+    };
+    "invalid-schema": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+    };
+    "union-null": {
+        readonly default: "Cannot have a union containing only null types.";
+    };
+    "union-unsupported": {
+        readonly default: "Unions are not supported unless all options are literals of the same type.";
+        readonly type: import("@typespec/compiler").CallableMessage<["kind"]>;
+        readonly empty: "Empty unions are not supported for OpenAPI v3 - enums must have at least one value.";
+        readonly null: "Unions containing multiple model types cannot be emitted to OpenAPI v2 unless the union is between one model type and 'null'.";
+    };
+    "invalid-default": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+    };
+    "inline-cycle": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+    };
+}[C]>(program: import("@typespec/compiler").Program, diag: import("@typespec/compiler").DiagnosticReport<{
+    "invalid-server-variable": {
+        readonly default: import("@typespec/compiler").CallableMessage<["propName"]>;
+    };
+    "resource-namespace": {
+        readonly default: "Resource goes on namespace";
+    };
+    "path-query": {
+        readonly default: "OpenAPI does not allow paths containing a query string.";
+    };
+    "duplicate-body": {
+        readonly default: "Duplicate @body declarations on response type";
+    };
+    "duplicate-header": {
+        readonly default: import("@typespec/compiler").CallableMessage<["header"]>;
+    };
+    "status-code-in-default-response": {
+        readonly default: "a default response should not have an explicit status code";
+    };
+    "invalid-schema": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+    };
+    "union-null": {
+        readonly default: "Cannot have a union containing only null types.";
+    };
+    "union-unsupported": {
+        readonly default: "Unions are not supported unless all options are literals of the same type.";
+        readonly type: import("@typespec/compiler").CallableMessage<["kind"]>;
+        readonly empty: "Empty unions are not supported for OpenAPI v3 - enums must have at least one value.";
+        readonly null: "Unions containing multiple model types cannot be emitted to OpenAPI v2 unless the union is between one model type and 'null'.";
+    };
+    "invalid-default": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+    };
+    "inline-cycle": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
+    };
+}, C, M>) => void, createStateSymbol: (name: string) => symbol;
+export type OpenAPILibrary = typeof $lib;
+//# 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":"AAAA,OAAO,EAAyB,cAAc,EAAgB,MAAM,oBAAoB,CAAC;AAEzF,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AACvC,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IAEH,WAAW,CAAC,EAAE,QAAQ,CAAC;IAEvB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B;;;OAGG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAcD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6ET,CAAC;AAEX,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAgC,CAAC;AAClD,eAAO,MAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAE,iBAAiB,0BAAS,CAAC;AAE5D,MAAM,MAAM,cAAc,GAAG,OAAO,IAAI,CAAC"}

package/dist/src/lib.js

@@ -0,0 +1,92 @@
+import { createTypeSpecLibrary, paramMessage } from "@typespec/compiler";
+const EmitterOptionsSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        "file-type": { type: "string", enum: ["yaml", "json"], nullable: true },
+        "output-file": { type: "string", nullable: true },
+        "new-line": { type: "string", enum: ["crlf", "lf"], default: "lf", nullable: true },
+        "omit-unreachable-types": { type: "boolean", nullable: true },
+    },
+    required: [],
+};
+export const libDef = {
+    name: "@typespec/openapi3",
+    diagnostics: {
+        "invalid-server-variable": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Server variable '${"propName"}' must be assignable to 'string'. It must either be a string, enum of string or union of strings.`,
+            },
+        },
+        "resource-namespace": {
+            severity: "error",
+            messages: {
+                default: "Resource goes on namespace",
+            },
+        },
+        "path-query": {
+            severity: "error",
+            messages: {
+                default: `OpenAPI does not allow paths containing a query string.`,
+            },
+        },
+        "duplicate-body": {
+            severity: "error",
+            messages: {
+                default: "Duplicate @body declarations on response type",
+            },
+        },
+        "duplicate-header": {
+            severity: "error",
+            messages: {
+                default: paramMessage `The header ${"header"} is defined across multiple content types`,
+            },
+        },
+        "status-code-in-default-response": {
+            severity: "error",
+            messages: {
+                default: "a default response should not have an explicit status code",
+            },
+        },
+        "invalid-schema": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Couldn't get schema for type ${"type"}`,
+            },
+        },
+        "union-null": {
+            severity: "error",
+            messages: {
+                default: "Cannot have a union containing only null types.",
+            },
+        },
+        "union-unsupported": {
+            severity: "error",
+            messages: {
+                default: "Unions are not supported unless all options are literals of the same type.",
+                type: paramMessage `Type "${"kind"}" cannot be used in unions`,
+                empty: "Empty unions are not supported for OpenAPI v3 - enums must have at least one value.",
+                null: "Unions containing multiple model types cannot be emitted to OpenAPI v2 unless the union is between one model type and 'null'.",
+            },
+        },
+        "invalid-default": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Invalid type '${"type"}' for a default value`,
+            },
+        },
+        "inline-cycle": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Cycle detected in '${"type"}'. Use @friendlyName decorator to assign an OpenAPI definition name and make it non-inline.`,
+            },
+        },
+    },
+    emitter: {
+        options: EmitterOptionsSchema,
+    },
+};
+export const $lib = createTypeSpecLibrary(libDef);
+export const { reportDiagnostic, createStateSymbol } = $lib;
+//# 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,EAAkB,YAAY,EAAE,MAAM,oBAAoB,CAAC;AA8BzF,MAAM,oBAAoB,GAA2C;IACnE,IAAI,EAAE,QAAQ;IACd,oBAAoB,EAAE,KAAK;IAC3B,UAAU,EAAE;QACV,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;QACvE,aAAa,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE;QACjD,UAAU,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE;QACnF,wBAAwB,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE;KAC9D;IACD,QAAQ,EAAE,EAAE;CACb,CAAC;AAEF,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EAAE;QACX,yBAAyB,EAAE;YACzB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,oBAAoB,UAAU,mGAAmG;aACvJ;SACF;QACD,oBAAoB,EAAE;YACpB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,4BAA4B;aACtC;SACF;QACD,YAAY,EAAE;YACZ,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,yDAAyD;aACnE;SACF;QACD,gBAAgB,EAAE;YAChB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,+CAA+C;aACzD;SACF;QACD,kBAAkB,EAAE;YAClB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,cAAc,QAAQ,2CAA2C;aACvF;SACF;QACD,iCAAiC,EAAE;YACjC,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,4DAA4D;aACtE;SACF;QACD,gBAAgB,EAAE;YAChB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,gCAAgC,MAAM,EAAE;aAC9D;SACF;QACD,YAAY,EAAE;YACZ,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,iDAAiD;aAC3D;SACF;QACD,mBAAmB,EAAE;YACnB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,4EAA4E;gBACrF,IAAI,EAAE,YAAY,CAAA,SAAS,MAAM,4BAA4B;gBAC7D,KAAK,EACH,qFAAqF;gBACvF,IAAI,EAAE,+HAA+H;aACtI;SACF;QACD,iBAAiB,EAAE;YACjB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,iBAAiB,MAAM,uBAAuB;aACpE;SACF;QACD,cAAc,EAAE;YACd,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE;gBACR,OAAO,EAAE,YAAY,CAAA,sBAAsB,MAAM,6FAA6F;aAC/I;SACF;KACF;IACD,OAAO,EAAE;QACP,OAAO,EAAE,oBAA8D;KACxE;CACO,CAAC;AAEX,MAAM,CAAC,MAAM,IAAI,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAClD,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAAC"}

package/dist/src/openapi.d.ts

@@ -0,0 +1,11 @@
+import { EmitContext, NewLine } from "@typespec/compiler";
+import { FileType, OpenAPI3EmitterOptions } from "./lib.js";
+export declare function $onEmit(context: EmitContext<OpenAPI3EmitterOptions>): Promise<void>;
+export declare function resolveOptions(context: EmitContext<OpenAPI3EmitterOptions>): ResolvedOpenAPI3EmitterOptions;
+export interface ResolvedOpenAPI3EmitterOptions {
+    fileType: FileType;
+    outputFile: string;
+    newLine: NewLine;
+    omitUnreachableTypes: boolean;
+}
+//# sourceMappingURL=openapi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/openapi.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,WAAW,EA2CX,OAAO,EAcR,MAAM,oBAAoB,CAAC;AAmC5B,OAAO,EAAE,QAAQ,EAAE,sBAAsB,EAAoB,MAAM,UAAU,CAAC;AAsB9E,wBAAsB,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,sBAAsB,CAAC,iBAIzE;AAgBD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,WAAW,CAAC,sBAAsB,CAAC,GAC3C,8BAA8B,CAahC;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,QAAQ,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,oBAAoB,EAAE,OAAO,CAAC;CAC/B"}