just-the-type 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Kneip
+
+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,85 @@
+# just-the-type
+
+Emitter to create TypeScript types from TypeSpec. No clients, no runtime, no
+serializers — just the types, built with the TypeScript compiler factory API.
+
+## Usage
+
+```sh
+pnpm add just-the-type
+tsp compile . --emit just-the-type
+```
+
+The emitter writes a single `types.ts` to `tsp-output/just-the-type/`.
+
+## What gets emitted
+
+| TypeSpec                                 | TypeScript                                     |
+| ---------------------------------------- | ---------------------------------------------- |
+| `model`                                  | `export interface` (with `extends`)            |
+| `model Wrapper<T>` (constraints/defaults) | generic `export interface Wrapper<T>`          |
+| `model Pets is Pet[]`                    | `export type Pets = Pet[]`                     |
+| `...Record<T>` spread                    | index signature `[key: string]: T`             |
+| `enum` (incl. spread)                    | `export enum`                                  |
+| named `union` (incl. generic)            | `export type` alias                            |
+| `op`                                     | `export type` function alias                   |
+| `interface`                              | `export interface` with method signatures      |
+| custom `scalar`                          | `export type` alias to its base primitive      |
+| doc comments / `@doc`                    | JSDoc comments                                 |
+| string templates `"a-${string}"`         | template literal types                         |
+| anonymous models, unions, intersections  | inlined structurally                           |
+| templates with `valueof` parameters      | declaration skipped, instantiations inlined    |
+| `int64` / `uint64`                       | `bigint`                                       |
+| other numerics                           | `number`                                       |
+| `bytes`                                  | `Uint8Array`                                   |
+| dates, times, `duration`, `url`          | `string`                                       |
+
+Not represented in the output: `alias` declarations (dissolved by the TypeSpec
+checker, their targets are inlined), values/`const`, and API-metadata decorators
+such as `@visibility`, `@format`, or `@encode` that do not change the type shape.
+
+## Decorators
+
+The library ships decorators for TypeScript features that TypeSpec cannot
+express. Import the library and bring them into scope:
+
+```typespec
+import "just-the-type";
+using JustTheType;
+```
+
+| Decorator                       | Target                     | Effect                                                       |
+| ------------------------------- | -------------------------- | ------------------------------------------------------------ |
+| `@promise`                      | `op`, `interface`          | Wraps return types in `Promise<T>`                           |
+| `@readonly`                     | property, `model`          | Emits the `readonly` modifier                                 |
+| `@tsType("Date")`               | `scalar`, property         | Replaces the emitted type with raw TypeScript                 |
+| `@tsType("Dayjs", "dayjs")`     | `scalar`, property         | Same, plus `import type { Dayjs } from "dayjs";`              |
+| `@literalUnion`                 | `enum`                     | Emits `type Color = "red" \| "blue"` instead of a TS enum     |
+
+`@tsType` also works on built-in scalars via augment decorators, e.g. map all
+`utcDateTime` to real `Date` objects:
+
+```typespec
+@@tsType(utcDateTime, "Date");
+```
+
+For qualified overrides such as `@tsType("Temporal.Instant", "@js-temporal/polyfill")`
+the root identifier (`Temporal`) is imported.
+
+## Development
+
+```sh
+pnpm install
+pnpm test        # vitest
+pnpm build       # tsc -> dist/
+```
+
+Try it on the sample:
+
+```sh
+pnpm sample    # tsp compile sample -> sample/tsp-output/
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/decorators.d.ts

@@ -0,0 +1,22 @@
+import { DecoratorContext, Enum, Interface, Model, ModelProperty, Operation, Program, Scalar, Type } from "@typespec/compiler";
+export interface TsTypeOverride {
+    type: string;
+    from?: string;
+}
+declare function $promise(context: DecoratorContext, target: Operation | Interface): void;
+declare function $readonly(context: DecoratorContext, target: ModelProperty | Model): void;
+declare function $tsType(context: DecoratorContext, target: Scalar | ModelProperty, type: string, importFrom?: string): void;
+declare function $literalUnion(context: DecoratorContext, target: Enum): void;
+export declare const $decorators: {
+    JustTheType: {
+        promise: typeof $promise;
+        readonly: typeof $readonly;
+        tsType: typeof $tsType;
+        literalUnion: typeof $literalUnion;
+    };
+};
+export declare function isAsync(program: Program, type: Type): boolean;
+export declare function isReadonly(program: Program, type: Type): boolean;
+export declare function getTsType(program: Program, type: Type): TsTypeOverride | undefined;
+export declare function isLiteralUnion(program: Program, type: Type): boolean;
+export {};

package/dist/decorators.js

@@ -0,0 +1,42 @@
+import { $lib } from "./lib.js";
+const keys = $lib.stateKeys;
+// Decorator arguments declared as `valueof string` arrive as plain strings;
+// without the extern declaration (e.g. in tests) they arrive as StringLiteral types.
+function asString(value) {
+    return typeof value === "object" ? value.value : value;
+}
+function $promise(context, target) {
+    context.program.stateSet(keys.async).add(target);
+}
+function $readonly(context, target) {
+    context.program.stateSet(keys.readonly).add(target);
+}
+function $tsType(context, target, type, importFrom) {
+    context.program.stateMap(keys.tsType).set(target, {
+        type: asString(type),
+        from: asString(importFrom),
+    });
+}
+function $literalUnion(context, target) {
+    context.program.stateSet(keys.literalUnion).add(target);
+}
+export const $decorators = {
+    JustTheType: {
+        promise: $promise,
+        readonly: $readonly,
+        tsType: $tsType,
+        literalUnion: $literalUnion,
+    },
+};
+export function isAsync(program, type) {
+    return program.stateSet(keys.async).has(type);
+}
+export function isReadonly(program, type) {
+    return program.stateSet(keys.readonly).has(type);
+}
+export function getTsType(program, type) {
+    return program.stateMap(keys.tsType).get(type);
+}
+export function isLiteralUnion(program, type) {
+    return program.stateSet(keys.literalUnion).has(type);
+}

package/dist/emitter.d.ts

@@ -0,0 +1,2 @@
+import { Program } from "@typespec/compiler";
+export declare function emitTypes(program: Program): string;

package/dist/emitter.js

@@ -0,0 +1,324 @@
+import { getDoc, isArrayModelType, isRecordModelType, isTemplateDeclaration, } from "@typespec/compiler";
+import ts from "typescript";
+import { getTsType, isAsync, isLiteralUnion, isReadonly } from "./decorators.js";
+const f = ts.factory;
+const stringType = () => f.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+const numberType = () => f.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+const bigintType = () => f.createKeywordTypeNode(ts.SyntaxKind.BigIntKeyword);
+const unknownType = () => f.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+const scalarMap = {
+    string: stringType,
+    boolean: () => f.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
+    bytes: () => f.createTypeReferenceNode("Uint8Array"),
+    int64: bigintType,
+    uint64: bigintType,
+    numeric: numberType,
+    integer: numberType,
+    float: numberType,
+    decimal: numberType,
+    decimal128: numberType,
+    float32: numberType,
+    float64: numberType,
+    int32: numberType,
+    int16: numberType,
+    int8: numberType,
+    safeint: numberType,
+    uint32: numberType,
+    uint16: numberType,
+    uint8: numberType,
+    url: stringType,
+    plainDate: stringType,
+    plainTime: stringType,
+    utcDateTime: stringType,
+    offsetDateTime: stringType,
+    duration: stringType,
+};
+const exportModifier = () => [f.createModifier(ts.SyntaxKind.ExportKeyword)];
+export function emitTypes(program) {
+    const ctx = { program, imports: new Map() };
+    const statements = [];
+    collectNamespace(ctx, program.getGlobalNamespaceType(), statements);
+    statements.unshift(...importDeclarations(ctx));
+    const file = ts.createSourceFile("types.ts", "", ts.ScriptTarget.ES2022, false, ts.ScriptKind.TS);
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    return printer.printList(ts.ListFormat.MultiLine, f.createNodeArray(statements), file);
+}
+function importDeclarations(ctx) {
+    return [...ctx.imports].map(([module, names]) => f.createImportDeclaration(undefined, f.createImportClause(ts.SyntaxKind.TypeKeyword, undefined, f.createNamedImports([...names].sort().map((name) => f.createImportSpecifier(false, undefined, f.createIdentifier(name))))), f.createStringLiteral(module)));
+}
+function collectNamespace(ctx, ns, statements) {
+    for (const model of ns.models.values()) {
+        if (isTemplateDeclaration(model) && !canEmitGeneric(ctx, model))
+            continue;
+        statements.push(modelDeclaration(ctx, model));
+    }
+    for (const scalar of ns.scalars.values()) {
+        if (!isTemplateDeclaration(scalar))
+            statements.push(scalarDeclaration(ctx, scalar));
+    }
+    for (const en of ns.enums.values())
+        statements.push(enumDeclaration(ctx, en));
+    for (const union of ns.unions.values()) {
+        if (!union.name)
+            continue;
+        if (isTemplateDeclaration(union) && !canEmitGeneric(ctx, union))
+            continue;
+        statements.push(withDoc(ctx, union, f.createTypeAliasDeclaration(exportModifier(), union.name, typeParameterDeclarations(ctx, union), unionToNode(ctx, union))));
+    }
+    for (const op of ns.operations.values()) {
+        if (isTemplateDeclaration(op))
+            continue;
+        statements.push(withDoc(ctx, op, f.createTypeAliasDeclaration(exportModifier(), op.name, undefined, f.createFunctionTypeNode(undefined, operationParameters(ctx, op), returnTypeNode(ctx, op)))));
+    }
+    for (const iface of ns.interfaces.values()) {
+        if (!isTemplateDeclaration(iface))
+            statements.push(interfaceDeclaration(ctx, iface));
+    }
+    for (const child of ns.namespaces.values()) {
+        if (child.name === "TypeSpec" && !child.namespace?.namespace)
+            continue;
+        collectNamespace(ctx, child, statements);
+    }
+}
+function modelDeclaration(ctx, model) {
+    const typeParameters = typeParameterDeclarations(ctx, model);
+    if (isArrayModelType(model)) {
+        return withDoc(ctx, model, f.createTypeAliasDeclaration(exportModifier(), model.name, typeParameters, f.createArrayTypeNode(typeToNode(ctx, model.indexer.value))));
+    }
+    const heritage = model.baseModel && namedReference(ctx, model.baseModel);
+    return withDoc(ctx, model, f.createInterfaceDeclaration(exportModifier(), model.name, typeParameters, heritage
+        ? [
+            f.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+                f.createExpressionWithTypeArguments(f.createIdentifier(heritage.name), heritage.args),
+            ]),
+        ]
+        : undefined, modelMembers(ctx, model)));
+}
+function modelMembers(ctx, model) {
+    const members = [...model.properties.values()].map((prop) => withDoc(ctx, prop, f.createPropertySignature(isReadonly(ctx.program, prop) || isReadonly(ctx.program, model)
+        ? [f.createModifier(ts.SyntaxKind.ReadonlyKeyword)]
+        : undefined, propertyName(prop.name), prop.optional ? f.createToken(ts.SyntaxKind.QuestionToken) : undefined, propertyTypeNode(ctx, prop))));
+    if (model.indexer && model.indexer.key.name === "string") {
+        members.push(f.createIndexSignature(undefined, [f.createParameterDeclaration(undefined, undefined, "key", undefined, stringType())], typeToNode(ctx, model.indexer.value)));
+    }
+    return members;
+}
+function propertyTypeNode(ctx, prop) {
+    const override = getTsType(ctx.program, prop);
+    return override ? overrideNode(ctx, override) : typeToNode(ctx, prop.type);
+}
+function overrideNode(ctx, override) {
+    if (override.from) {
+        const root = override.type.split(/[.<]/)[0];
+        const names = ctx.imports.get(override.from) ?? new Set();
+        names.add(root);
+        ctx.imports.set(override.from, names);
+    }
+    return f.createTypeReferenceNode(override.type);
+}
+function propertyName(name) {
+    return /^[A-Za-z_$][\w$]*$/.test(name) ? f.createIdentifier(name) : f.createStringLiteral(name);
+}
+function enumDeclaration(ctx, en) {
+    if (isLiteralUnion(ctx.program, en)) {
+        return withDoc(ctx, en, f.createTypeAliasDeclaration(exportModifier(), en.name, undefined, f.createUnionTypeNode([...en.members.values()].map((member) => literalNode(member.value ?? member.name)))));
+    }
+    const members = [...en.members.values()].map((member) => {
+        const value = member.value ?? member.name;
+        return withDoc(ctx, member, f.createEnumMember(propertyName(member.name), typeof value === "number" ? f.createNumericLiteral(value) : f.createStringLiteral(value)));
+    });
+    return withDoc(ctx, en, f.createEnumDeclaration(exportModifier(), en.name, members));
+}
+function literalNode(value) {
+    return f.createLiteralTypeNode(typeof value === "number" ? f.createNumericLiteral(value) : f.createStringLiteral(value));
+}
+function scalarDeclaration(ctx, scalar) {
+    const override = getTsType(ctx.program, scalar);
+    const base = scalar.baseScalar;
+    const node = override
+        ? overrideNode(ctx, override)
+        : !base
+            ? unknownType()
+            : inStdNamespace(base)
+                ? stdScalarNode(ctx, base)
+                : f.createTypeReferenceNode(base.name);
+    return withDoc(ctx, scalar, f.createTypeAliasDeclaration(exportModifier(), scalar.name, undefined, node));
+}
+function returnTypeNode(ctx, op, container) {
+    const node = typeToNode(ctx, op.returnType);
+    const async = isAsync(ctx.program, op) || (container !== undefined && isAsync(ctx.program, container));
+    return async ? f.createTypeReferenceNode("Promise", [node]) : node;
+}
+function operationParameters(ctx, op) {
+    return [...op.parameters.properties.values()].map((prop) => f.createParameterDeclaration(undefined, undefined, prop.name, prop.optional ? f.createToken(ts.SyntaxKind.QuestionToken) : undefined, propertyTypeNode(ctx, prop)));
+}
+function interfaceDeclaration(ctx, iface) {
+    const members = [...iface.operations.values()].map((op) => withDoc(ctx, op, f.createMethodSignature(undefined, op.name, undefined, undefined, operationParameters(ctx, op), returnTypeNode(ctx, op, iface))));
+    return withDoc(ctx, iface, f.createInterfaceDeclaration(exportModifier(), iface.name, undefined, undefined, members));
+}
+function unionToNode(ctx, union) {
+    return f.createUnionTypeNode([...union.variants.values()].map((variant) => typeToNode(ctx, variant.type)));
+}
+function typeToNode(ctx, type) {
+    switch (type.kind) {
+        case "Model": {
+            // Inside template declarations Array<T>/Record<T> instances carry no
+            // indexer yet, so resolve them via their template argument instead.
+            const element = (type.name === "Array" || type.name === "Record") && inStdNamespace(type)
+                ? (type.indexer?.value ?? typeArgument(type))
+                : undefined;
+            if (element) {
+                return type.name === "Array"
+                    ? f.createArrayTypeNode(typeToNode(ctx, element))
+                    : f.createTypeReferenceNode("Record", [stringType(), typeToNode(ctx, element)]);
+            }
+            if (isArrayModelType(type)) {
+                return f.createArrayTypeNode(typeToNode(ctx, type.indexer.value));
+            }
+            if (isRecordModelType(type)) {
+                return f.createTypeReferenceNode("Record", [stringType(), typeToNode(ctx, type.indexer.value)]);
+            }
+            const ref = namedReference(ctx, type);
+            return ref
+                ? f.createTypeReferenceNode(ref.name, ref.args)
+                : f.createTypeLiteralNode(modelMembers(ctx, type));
+        }
+        case "Scalar":
+            // User scalars are declared as aliases, so a @tsType override applies
+            // at the declaration site and references keep using the scalar's name.
+            return inStdNamespace(type) ? stdScalarNode(ctx, type) : f.createTypeReferenceNode(type.name);
+        case "Enum":
+            return f.createTypeReferenceNode(type.name);
+        case "EnumMember":
+            if (isLiteralUnion(ctx.program, type.enum)) {
+                return literalNode(type.value ?? type.name);
+            }
+            return f.createTypeReferenceNode(f.createQualifiedName(f.createIdentifier(type.enum.name), type.name));
+        case "Union": {
+            const ref = type.name ? namedReference(ctx, type) : undefined;
+            return ref ? f.createTypeReferenceNode(ref.name, ref.args) : unionToNode(ctx, type);
+        }
+        case "Tuple": {
+            const tuple = f.createTupleTypeNode(type.values.map((value) => typeToNode(ctx, value)));
+            return ts.setEmitFlags(tuple, ts.EmitFlags.SingleLine);
+        }
+        case "TemplateParameter":
+            return f.createTypeReferenceNode(type.node.id.sv);
+        case "String":
+            return f.createLiteralTypeNode(f.createStringLiteral(type.value));
+        case "Number":
+            return f.createLiteralTypeNode(f.createNumericLiteral(type.value));
+        case "Boolean":
+            return f.createLiteralTypeNode(type.value ? f.createTrue() : f.createFalse());
+        case "StringTemplate":
+            return stringTemplateToNode(ctx, type);
+        case "Intrinsic":
+            switch (type.name) {
+                case "null":
+                    return f.createLiteralTypeNode(f.createNull());
+                case "void":
+                    return f.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
+                case "never":
+                    return f.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword);
+                default:
+                    return unknownType();
+            }
+        default:
+            return unknownType();
+    }
+}
+function stringTemplateToNode(ctx, template) {
+    if (template.stringValue !== undefined) {
+        return f.createLiteralTypeNode(f.createStringLiteral(template.stringValue));
+    }
+    const spans = [...template.spans];
+    let i = 0;
+    let head = "";
+    while (i < spans.length && !spans[i].isInterpolated) {
+        head += spans[i].type.value;
+        i++;
+    }
+    const tsSpans = [];
+    while (i < spans.length) {
+        const inner = typeToNode(ctx, spans[i].type);
+        i++;
+        let text = "";
+        while (i < spans.length && !spans[i].isInterpolated) {
+            text += spans[i].type.value;
+            i++;
+        }
+        tsSpans.push(f.createTemplateLiteralTypeSpan(inner, i >= spans.length ? f.createTemplateTail(text) : f.createTemplateMiddle(text)));
+    }
+    return f.createTemplateLiteralType(f.createTemplateHead(head), tsSpans);
+}
+function typeArgument(type) {
+    const arg = type.templateMapper?.args[0];
+    return arg?.entityKind === "Type" ? arg : undefined;
+}
+function namedReference(ctx, type) {
+    if (!type.name || inStdNamespace(type))
+        return undefined;
+    if (!type.templateMapper)
+        return { name: type.name };
+    if (!canEmitGeneric(ctx, type))
+        return undefined;
+    const args = [];
+    for (const arg of type.templateMapper.args) {
+        if (arg.entityKind !== "Type")
+            return undefined;
+        args.push(typeToNode(ctx, arg));
+    }
+    return { name: type.name, args };
+}
+function templateParamNodes(type) {
+    const node = type.node;
+    return node?.templateParameters ?? [];
+}
+// `valueof` constraints have no type-level equivalent; the checker resolves
+// them to ErrorType, which marks the template as not emittable as a generic.
+function resolveExpression(ctx, expr) {
+    const type = ctx.program.checker.getTypeForNode(expr);
+    return type.kind === "Intrinsic" && type.name === "ErrorType" ? undefined : type;
+}
+function canEmitGeneric(ctx, type) {
+    return templateParamNodes(type).every((param) => !param.constraint || resolveExpression(ctx, param.constraint));
+}
+function typeParameterDeclarations(ctx, type) {
+    const params = templateParamNodes(type);
+    if (params.length === 0)
+        return undefined;
+    return params.map((param) => {
+        const constraint = param.constraint && resolveExpression(ctx, param.constraint);
+        const defaultType = param.default && resolveExpression(ctx, param.default);
+        return f.createTypeParameterDeclaration(undefined, param.id.sv, constraint && typeToNode(ctx, constraint), defaultType && typeToNode(ctx, defaultType));
+    });
+}
+function stdScalarNode(ctx, scalar) {
+    let current = scalar;
+    while (current) {
+        const override = getTsType(ctx.program, current);
+        if (override)
+            return overrideNode(ctx, override);
+        const mapped = scalarMap[current.name];
+        if (mapped)
+            return mapped();
+        current = current.baseScalar;
+    }
+    return unknownType();
+}
+function inStdNamespace(type) {
+    let ns = type.namespace;
+    while (ns?.namespace) {
+        if (!ns.namespace.name && !ns.namespace.namespace)
+            return ns.name === "TypeSpec";
+        ns = ns.namespace;
+    }
+    return false;
+}
+function withDoc(ctx, type, node) {
+    const doc = getDoc(ctx.program, type);
+    if (doc) {
+        ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `* ${doc.replace(/\n/g, "\n * ")} `, true);
+    }
+    return node;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { EmitContext } from "@typespec/compiler";
+export { $decorators } from "./decorators.js";
+export { emitTypes } from "./emitter.js";
+export { $lib } from "./lib.js";
+export declare function $onEmit(context: EmitContext): Promise<void>;

package/dist/index.js

@@ -0,0 +1,13 @@
+import { emitFile, resolvePath } from "@typespec/compiler";
+import { emitTypes } from "./emitter.js";
+export { $decorators } from "./decorators.js";
+export { emitTypes } from "./emitter.js";
+export { $lib } from "./lib.js";
+export async function $onEmit(context) {
+    if (context.program.compilerOptions.noEmit)
+        return;
+    await emitFile(context.program, {
+        path: resolvePath(context.emitterOutputDir, "types.ts"),
+        content: emitTypes(context.program),
+    });
+}

package/dist/lib.d.ts

@@ -0,0 +1,3 @@
+export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
+    [code: string]: import("@typespec/compiler").DiagnosticMessages;
+}, Record<string, any>, "async" | "readonly" | "tsType" | "literalUnion">;

package/dist/lib.js

@@ -0,0 +1,11 @@
+import { createTypeSpecLibrary } from "@typespec/compiler";
+export const $lib = createTypeSpecLibrary({
+    name: "just-the-type",
+    diagnostics: {},
+    state: {
+        async: { description: "Operations and interfaces whose return types are wrapped in Promise" },
+        readonly: { description: "Properties and models emitted with the readonly modifier" },
+        tsType: { description: "Raw TypeScript type overrides with optional import source" },
+        literalUnion: { description: "Enums emitted as unions of literals instead of TS enums" },
+    },
+});

package/lib/main.tsp

@@ -0,0 +1,21 @@
+import "../dist/index.js";
+
+using TypeSpec.Reflection;
+
+namespace JustTheType;
+
+/** Wrap the return type of the operation (or all operations of an interface) in Promise. */
+extern dec promise(target: Operation | Interface);
+
+/** Emit the property (or all properties of the model) with the readonly modifier. */
+extern dec readonly(target: ModelProperty | Model);
+
+/**
+ * Replace the emitted type with raw TypeScript.
+ * @param type TypeScript type text, e.g. "Date" or "Temporal.Instant".
+ * @param importFrom Optional module to type-import the type's root identifier from.
+ */
+extern dec tsType(target: Scalar | ModelProperty, type: valueof string, importFrom?: valueof string);
+
+/** Emit the enum as a union of its literal values instead of a TS enum. */
+extern dec literalUnion(target: Enum);

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "just-the-type",
+  "version": "0.1.0",
+  "description": "TypeSpec emitter that emits plain TypeScript types",
+  "keywords": [
+    "typespec",
+    "typespec-emitter",
+    "typescript",
+    "codegen",
+    "types"
+  ],
+  "license": "MIT",
+  "author": "Daniel Kneip",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daniel-kneip/just-the-type.git"
+  },
+  "homepage": "https://github.com/daniel-kneip/just-the-type#readme",
+  "bugs": "https://github.com/daniel-kneip/just-the-type/issues",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "typespec": "./lib/main.tsp",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@typespec/compiler": ">=1.0.0"
+  },
+  "dependencies": {
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@typespec/compiler": "1.13.0",
+    "vitest": "4.1.8"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "sample": "tsp compile sample"
+  }
+}