@typespec/emitter-framework 0.11.0-dev.0 → 0.11.0-dev.2

package/dist/src/typescript/components/type-transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-transform.d.ts","sourceRoot":"","sources":["../../../../src/typescript/components/type-transform.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAsB,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEhF,OAAO,KAAK,EAEV,KAAK,EAIL,IAAI,EACJ,KAAK,EACN,MAAM,oBAAoB,CAAC;AAc5B,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,CAAC;IACZ,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC;CACrC;AA+DD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,kBAAkB,YAqEjE;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,GAAG,WAAW,UAEvF;AAED,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,KAAK,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC;IACpC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,6BAA6B,YAwE5E;AAyDD,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;IACX;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;OAEG;IACH,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC;IACpC;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,QAAQ,CAuEzE"}
+{"version":3,"file":"type-transform.d.ts","sourceRoot":"","sources":["../../../../src/typescript/components/type-transform.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAsB,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEhF,OAAO,KAAK,EAEV,KAAK,EAIL,IAAI,EACJ,KAAK,EACN,MAAM,oBAAoB,CAAC;AAc5B,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,CAAC;IACZ,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC;CACrC;AA+DD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,kBAAkB,YAqEjE;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,GAAG,WAAW,UAEvF;AAED,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,KAAK,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC;IACpC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,6BAA6B,YAwE5E;AAyDD,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;IACX;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;OAEG;IACH,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC;IACpC;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,QAAQ,CAmEzE"}

package/dist/src/typescript/components/type-transform.js

@@ -205,7 +205,7 @@ export function ModelTransformExpression(props) {
   return _$createComponent(ts.ObjectExpression, {
     get children() {
       return [baseModelTransform, _$memo(() => mapJoin(() => modelProperties, (_, property) => {
-        const unpackedType = $.httpPart.unpack(property.type) ?? property.type;
+        const unpackedType = property.type;
         let targetPropertyName = property.name;
         let sourcePropertyName = namePolicy.getName(property.name, "interface-member");
         if (props.target === "application") {
@@ -346,7 +346,7 @@ export function TypeTransformCall(props) {
   }
   const transformType = collapsedProperty?.type ?? props.type;
   if ($.model.is(transformType) && $.array.is(transformType)) {
-    const unpackedElement = $.httpPart.unpack($.array.getElementType(transformType)) ?? $.array.getElementType(transformType);
+    const unpackedElement = $.array.getElementType(transformType);
     return _$createComponent(ts.FunctionCallExpression, {
       target: ArraySerializerRefkey,
       get args() {
@@ -360,7 +360,7 @@ export function TypeTransformCall(props) {
     });
   }
   if ($.model.is(transformType) && $.record.is(transformType)) {
-    const unpackedElement = $.httpPart.unpack($.record.getElementType(transformType)) ?? $.record.getElementType(transformType);
+    const unpackedElement = $.record.getElementType(transformType);
     return _$createComponent(ts.FunctionCallExpression, {
       target: RecordSerializerRefkey,
       get args() {

package/dist/test/typescript/components/component-override.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=component-override.test.d.ts.map

package/dist/test/typescript/components/component-override.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-override.test.d.ts","sourceRoot":"","sources":["../../../../test/typescript/components/component-override.test.tsx"],"names":[],"mappings":""}

package/dist/test/typescript/components/component-override.test.js

@@ -0,0 +1,77 @@
+import { memo as _$memo, createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { Experimental_ComponentOverrides, Experimental_ComponentOverridesConfig } from "#core/index.js";
+import { FunctionDeclaration } from "#typescript/index.js";
+import { For, List } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import { expect, it } from "vitest";
+import { Output } from "../../../src/core/components/output.js";
+import { InterfaceDeclaration } from "../../../src/typescript/components/interface-declaration.js";
+import { Tester } from "../../test-host.js";
+it("uses overridden component", async () => {
+  const {
+    program
+  } = await Tester.compile(`
+          namespace DemoService;
+          model Foo {
+            knownProp: string;
+          }
+
+          op foo(): Foo;
+
+          `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const models = Array.from(namespace.models.values());
+  const operations = Array.from(namespace.operations.values());
+  expect(_$createComponent(Output, {
+    program: program,
+    get children() {
+      return _$createComponent(TestClientOverrides, {
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.ts",
+            get children() {
+              return [_$createComponent(List, {
+                hardline: true,
+                get children() {
+                  return models.map(model => _$createComponent(InterfaceDeclaration, {
+                    "export": true,
+                    type: model
+                  }));
+                }
+              }), _$createIntrinsic("hbr", {}), _$createComponent(For, {
+                each: operations,
+                children: operation => _$createComponent(FunctionDeclaration, {
+                  "export": true,
+                  type: operation
+                })
+              })];
+            }
+          });
+        }
+      });
+    }
+  })).toRenderTo(d`
+      export interface Foo {
+        knownProp: string;
+      }
+      export function foo(): unknown {}
+            `);
+});
+function TestClientOverrides(props) {
+  const overrides = Experimental_ComponentOverridesConfig().forTypeKind("Model", {
+    reference: props => {
+      if (props.type.name === "Foo") {
+        return "unknown";
+      } else {
+        return props.default;
+      }
+    }
+  });
+  return _$createComponent(Experimental_ComponentOverrides, {
+    overrides: overrides,
+    get children() {
+      return props.children;
+    }
+  });
+}

package/dist/test/typescript/test-host.d.ts

@@ -1,13 +1,9 @@
 import type { Program } from "@typespec/compiler";
-export declare function createTypespecCliTestHost(options?: {
-    libraries: "Http"[];
-}): Promise<import("@typespec/compiler/testing").TestHost>;
+export declare function createTypespecCliTestHost(): Promise<import("@typespec/compiler/testing").TestHost>;
 export declare function createEmitterFrameworkTestRunner(options?: {
     autoUsings?: string[];
 }): Promise<import("@typespec/compiler/testing").BasicTestRunner>;
-export declare function getProgram(code: string, options?: {
-    libraries: "Http"[];
-}): Promise<Program>;
+export declare function getProgram(code: string): Promise<Program>;
 /**
  * Initializes an empty program in the compiler.
  * This is useful when you want to initialize the default TypeKits without any code.

package/dist/test/typescript/test-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-host.d.ts","sourceRoot":"","sources":["../../../test/typescript/test-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAQlD,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,0DASrD;AAED,wBAAsB,gCAAgC,CAAC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,iEAK7F;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,GACnD,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEtD"}
+{"version":3,"file":"test-host.d.ts","sourceRoot":"","sources":["../../../test/typescript/test-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAOlD,wBAAsB,yBAAyB,2DAE9C;AAED,wBAAsB,gCAAgC,CAAC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,iEAK7F;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAU/D;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEtD"}

package/dist/test/typescript/test-host.js

@@ -1,15 +1,6 @@
 import { createTestHost, createTestWrapper, expectDiagnosticEmpty } from "@typespec/compiler/testing";
-import { HttpTestLibrary } from "@typespec/http/testing";
-export async function createTypespecCliTestHost(options = {
-  libraries: []
-}) {
-  const libraries = [];
-  if (options.libraries.includes("Http")) {
-    libraries.push(HttpTestLibrary);
-  }
-  return createTestHost({
-    libraries
-  });
+export async function createTypespecCliTestHost() {
+  return createTestHost({});
 }
 export async function createEmitterFrameworkTestRunner(options = {}) {
   const host = await createTypespecCliTestHost();
@@ -17,10 +8,8 @@ export async function createEmitterFrameworkTestRunner(options = {}) {
     autoUsings: options.autoUsings
   });
 }
-export async function getProgram(code, options = {
-  libraries: []
-}) {
-  const host = await createTypespecCliTestHost(options);
+export async function getProgram(code) {
+  const host = await createTypespecCliTestHost();
   const wrapper = createTestWrapper(host, {
     compilerOptions: {
       noEmit: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/emitter-framework",
-  "version": "0.11.0-dev.0",
+  "version": "0.11.0-dev.2",
   "type": "module",
   "main": "dist/index.js",
   "repository": {
@@ -44,9 +44,7 @@
     "@alloy-js/core": "^0.19.0",
     "@alloy-js/csharp": "^0.19.0",
     "@alloy-js/typescript": "^0.19.0",
-    "@typespec/compiler": "^1.3.0",
-    "@typespec/http": "^1.3.0",
-    "@typespec/rest": "^0.73.0 || >=0.74.0-dev <0.74.0"
+    "@typespec/compiler": "^1.3.0"
   },
   "devDependencies": {
     "@alloy-js/cli": "^0.19.0",
@@ -54,8 +52,6 @@
     "@alloy-js/rollup-plugin": "^0.1.0",
     "@alloy-js/typescript": "^0.19.0",
     "@typespec/compiler": "^1.3.0",
-    "@typespec/http": "^1.3.0",
-    "@typespec/rest": "^0.73.0 || >=0.74.0-dev <0.74.0",
     "concurrently": "^9.1.2",
     "pathe": "^2.0.3",
     "prettier": "~3.6.2",

package/src/core/components/index.tsx

@@ -1 +1,3 @@
 export * from "./output.jsx";
+export * from "./overrides/component-overrides.jsx";
+export * from "./overrides/config.js";

package/src/core/components/overrides/component-overrides.tsx

@@ -0,0 +1,134 @@
+import { type Children, type ComponentDefinition } from "@alloy-js/core";
+import type { ObjectPropertyProps, VarDeclarationProps } from "@alloy-js/typescript";
+import type {
+  Enum,
+  EnumMember,
+  Model,
+  ModelProperty,
+  Scalar,
+  Type,
+  Union,
+  UnionVariant,
+} from "@typespec/compiler";
+import { useTsp } from "../../context/index.js";
+import {
+  type Experimental_ComponentOverridesConfig,
+  getOverrideForType,
+  getOverridesForTypeKind,
+} from "./config.js";
+import { type ComponentOverridesContext, OverridesContext, useOverrides } from "./context.js";
+
+export interface Experimental_OverrideEmitPropsBase<TCustomType extends Type> {
+  /**
+   * The TypeSpec type to render.
+   */
+  type: TCustomType;
+
+  /**
+   * The default emitted output for this type.
+   */
+  default: Children;
+}
+
+export type Experimental_CustomTypeToProps<TCustomType extends Type> =
+  TCustomType extends ModelProperty
+    ? ObjectPropertyProps
+    : TCustomType extends EnumMember
+      ? {}
+      : TCustomType extends UnionVariant
+        ? {}
+        : TCustomType extends Model | Scalar | Union | Enum
+          ? VarDeclarationProps
+          : VarDeclarationProps | ObjectPropertyProps;
+
+export interface Experimental_OverrideReferenceProps<TCustomType extends Type>
+  extends Experimental_OverrideEmitPropsBase<TCustomType> {
+  /**
+   * The member this type is referenced from, if any. This member may contain
+   * additional metadata that should be represented in the emitted output.
+   */
+  member?: ModelProperty;
+}
+
+export interface Experimental_OverrideDeclareProps<TCustomType extends Type>
+  extends Experimental_OverrideEmitPropsBase<TCustomType> {
+  Declaration: ComponentDefinition<Experimental_CustomTypeToProps<TCustomType>>;
+  declarationProps: Experimental_CustomTypeToProps<TCustomType>;
+}
+
+export type Experimental_OverrideDeclarationComponent<TCustomType extends Type> =
+  ComponentDefinition<Experimental_OverrideDeclareProps<TCustomType>>;
+
+export type Experimental_OverrideReferenceComponent<TCustomType extends Type> = ComponentDefinition<
+  Experimental_OverrideReferenceProps<TCustomType>
+>;
+
+export interface Experimental_ComponentOverridesConfigBase<TCustomType extends Type> {
+  /**
+   * Override when this type is referenced.
+   * e.g. When used in <TypeExpression type={type} />
+   */
+  reference?: Experimental_OverrideReferenceComponent<TCustomType>;
+}
+
+export interface Experimental_ComponentOverridesProps {
+  overrides: Experimental_ComponentOverridesConfig;
+  children?: Children;
+}
+export function Experimental_ComponentOverrides(props: Experimental_ComponentOverridesProps) {
+  const context: ComponentOverridesContext = {
+    overrides: props.overrides,
+  };
+
+  return <OverridesContext.Provider value={context}>{props.children}</OverridesContext.Provider>;
+}
+
+export interface Experimental_OverrideTypeComponentCommonProps<T extends Type> {
+  /**
+   * The TypeSpec type to render.
+   */
+  type: T;
+
+  /**
+   * The default rendering.
+   */
+  children: Children;
+}
+
+export interface Experimental_OverridableComponentReferenceProps<T extends Type>
+  extends Experimental_OverrideTypeComponentCommonProps<T> {
+  /**
+   * Pass when rendering a reference to the provided type or type kind.
+   */
+  reference: true;
+
+  /**
+   * The member this type is referenced from, if any. This member may contain
+   * additional metadata that should be represented in the emitted output.
+   */
+  member?: ModelProperty;
+}
+
+export type Experimental_OverridableComponentProps<T extends Type> =
+  Experimental_OverridableComponentReferenceProps<T>;
+
+export function Experimental_OverridableComponent<T extends Type>(
+  props: Experimental_OverridableComponentProps<T>,
+) {
+  const options = useOverrides();
+  const { $ } = useTsp();
+  const descriptor =
+    getOverrideForType($.program, props.type, options.overrides) ??
+    getOverridesForTypeKind($.program, props.type.kind, options.overrides);
+
+  if (!descriptor) {
+    return <>{props.children}</>;
+  }
+
+  if ("reference" in props && props.reference && descriptor.reference) {
+    const CustomComponent = descriptor.reference;
+    return <CustomComponent type={props.type} member={props.member} default={props.children} />;
+  }
+
+  return <>{props.children}</>;
+}

package/src/core/components/overrides/config.ts

@@ -0,0 +1,85 @@
+import type { Program, Scalar, Type } from "@typespec/compiler";
+import { $ } from "@typespec/compiler/typekit";
+import type { Experimental_ComponentOverridesConfigBase } from "./component-overrides.jsx";
+
+const getOverrideForTypeSym: unique symbol = Symbol.for("ef-ts:getOverrideForType");
+const getOverrideForTypeKindSym: unique symbol = Symbol.for("ef-ts:getOverrideForTypeKind");
+
+export type Experimental_ComponentOverridesConfig = Experimental_ComponentOverridesClass;
+export const Experimental_ComponentOverridesConfig = function () {
+  return new Experimental_ComponentOverridesClass();
+} as {
+  new (): Experimental_ComponentOverridesClass;
+  (): Experimental_ComponentOverridesClass;
+};
+
+export class Experimental_ComponentOverridesClass {
+  #typeEmitOptions: Map<Type, Experimental_ComponentOverridesConfigBase<any>> = new Map();
+  #typeKindEmitOptions: Map<Type["kind"], Experimental_ComponentOverridesConfigBase<any>> =
+    new Map();
+
+  forType<const T extends Type>(type: T, options: Experimental_ComponentOverridesConfigBase<T>) {
+    this.#typeEmitOptions.set(type, options);
+
+    return this;
+  }
+
+  forTypeKind<const TKind extends Type["kind"]>(
+    typeKind: TKind,
+    options: Experimental_ComponentOverridesConfigBase<Extract<Type, { kind: TKind }>>,
+  ) {
+    this.#typeKindEmitOptions.set(typeKind, options);
+
+    return this;
+  }
+
+  /**
+   * @internal
+   */
+  [getOverrideForTypeSym](program: Program, type: Type) {
+    const options = this.#typeEmitOptions.get(type);
+    if (options || !$(program).scalar.is(type) /** || isBuiltIn(program, type) */) {
+      return options;
+    }
+
+    // have a scalar, it's not a built-in scalar, and didn't find options, so
+    // see if we have options for a base scalar.
+    let currentScalar: Scalar | undefined = type;
+    while (
+      currentScalar &&
+      // !isBuiltIn(program, currentScalar) &&
+      !this.#typeEmitOptions.has(currentScalar)
+    ) {
+      currentScalar = currentScalar?.baseScalar;
+    }
+
+    if (!currentScalar) {
+      return undefined;
+    }
+
+    return this.#typeEmitOptions.get(currentScalar);
+  }
+
+  /**
+   * @internal
+   */
+  [getOverrideForTypeKindSym](program: Program, typeKind: Type["kind"]) {
+    return this.#typeKindEmitOptions.get(typeKind);
+  }
+}
+
+export function getOverrideForType(
+  program: Program,
+  type: Type,
+  options?: Experimental_ComponentOverridesConfig,
+) {
+  return options?.[getOverrideForTypeSym](program, type);
+}
+
+export function getOverridesForTypeKind(
+  program: Program,
+  typeKind: Type["kind"],
+  options?: Experimental_ComponentOverridesConfig,
+) {
+  return options?.[getOverrideForTypeKindSym](program, typeKind);
+}

package/src/core/components/overrides/context.ts

@@ -0,0 +1,14 @@
+import { createContext, useContext, type ComponentContext } from "@alloy-js/core";
+import type { Experimental_ComponentOverridesConfig } from "./config.js";
+
+export interface ComponentOverridesContext {
+  overrides?: Experimental_ComponentOverridesConfig;
+}
+/**
+ * Context for setting overrides for components
+ */
+export const OverridesContext: ComponentContext<ComponentOverridesContext> = createContext({});
+
+export function useOverrides(): ComponentOverridesContext {
+  return useContext(OverridesContext)!;
+}

package/src/csharp/components/class/declaration.test.tsx

@@ -1,5 +1,10 @@
+import {
+  Experimental_ComponentOverrides,
+  Experimental_ComponentOverridesConfig,
+} from "#core/index.js";
 import { Tester } from "#test/test-host.js";
-import { type Children } from "@alloy-js/core";
+import { List, type Children } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
 import { createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
 import { t, type TesterInstance } from "@typespec/compiler/testing";
 import { beforeEach, describe, expect, it } from "vitest";
@@ -67,6 +72,65 @@ it("renders a class declaration with properties", async () => {
   `);
 });
 
+it("renders a class declaration with properties using component override", async () => {
+  const { TestModel, Foo, Bar } = await runner.compile(t.code`
+    model ${t.model("Foo")} {}
+    model ${t.model("Bar")} {}
+    model ${t.model("TestModel")} {
+      Prop1: string;
+      Prop2: int32;
+      Prop3?: Foo;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <TestClientOverrides>
+        <List hardline>
+          <ClassDeclaration type={Foo} />
+          <ClassDeclaration type={Bar} />
+          <ClassDeclaration type={TestModel} />
+        </List>
+      </TestClientOverrides>
+    </Wrapper>,
+  ).toRenderTo(d`
+    namespace TestNamespace
+    {
+        class Foo
+        {
+
+        }
+        class Bar
+        {
+
+        }
+        class TestModel
+        {
+            public required string Prop1 { get; set; }
+            public required int Prop2 { get; set; }
+            public Bar Prop3 { get; set; }
+        }
+    }
+  `);
+});
+
+function TestClientOverrides(props: { children?: Children }) {
+  const overrides = Experimental_ComponentOverridesConfig().forTypeKind("Model", {
+    reference: (props) => {
+      if (props.type.name === "Foo") {
+        return "Bar";
+      } else {
+        return props.default;
+      }
+    },
+  });
+  return (
+    <Experimental_ComponentOverrides overrides={overrides}>
+      {props.children}
+    </Experimental_ComponentOverrides>
+  );
+}
+
 it("can override class name", async () => {
   const { TestModel } = await runner.compile(t.code`
     model ${t.model("TestModel")} {}

package/src/csharp/components/class/declaration.tsx

@@ -1,7 +1,7 @@
-import { type Children, For } from "@alloy-js/core";
+import { For, type Children } from "@alloy-js/core";
 import * as cs from "@alloy-js/csharp";
 import { Method } from "@alloy-js/csharp";
-import type { Interface, Model } from "@typespec/compiler";
+import { isVoidType, type Interface, type Model } from "@typespec/compiler";
 import { useTsp } from "../../../core/index.js";
 import { Property } from "../property/property.jsx";
 import { TypeExpression } from "../type-expression.jsx";
@@ -53,8 +53,12 @@ export function ClassDeclaration(props: ClassDeclarationProps): Children {
 }
 
 function ClassProperties(props: ClassPropertiesProps): Children {
+  // Ignore 'void' type properties which is not valid in csharp
+  const properties = Array.from(props.type.properties.entries()).filter(
+    ([_, p]) => !isVoidType(p.type),
+  );
   return (
-    <For each={props.type.properties.entries()} hardline>
+    <For each={properties} hardline>
       {([name, property]) => <Property type={property} jsonAttributes={props.jsonAttributes} />}
     </For>
   );

package/src/csharp/components/type-expression.test.tsx

@@ -131,3 +131,67 @@ describe("Record map to IDictionary", () => {
     );
   });
 });
+
+describe("Nullable union", () => {
+  it("nullable boolean", async () => {
+    const { Pet } = (await runner.compile(`
+      @test model Pet {
+        @test name: boolean | null;
+      }
+    `)) as { Pet: Model };
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={Pet} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              class Pet
+              {
+                  public required bool? name { get; set; }
+              }
+          }
+        `,
+    );
+  });
+});
+
+describe("Literal types", () => {
+  it("literal types (string, int, double, bool)", async () => {
+    const { Pet } = (await runner.compile(`
+      @test model Pet {
+        @test boolName: true;
+        @test intName: 42;
+        @test doubleName: 3.14;
+        @test stringName: "Hello";
+      }
+    `)) as { Pet: Model };
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={Pet} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              class Pet
+              {
+                  public required bool boolName { get; set; }
+                  public required int intName { get; set; }
+                  public required double doubleName { get; set; }
+                  public required string stringName { get; set; }
+              }
+          }
+        `,
+    );
+  });
+});