@alloy-js/csharp 0.23.0-dev.6 → 0.23.0-dev.8

package/docs/api/functions/createFieldSymbol.md

@@ -0,0 +1,43 @@
+# createFieldSymbol
+
+```ts
+import { createFieldSymbol } from "@alloy-js/csharp";
+
+
+function createFieldSymbol(originalName: string | Namekey, options?: CSharpSymbolOptions): CSharpSymbol;
+```
+
+## Parameters
+
+|              |                              |   |
+| ------------ | ---------------------------- | - |
+| originalName | string \| Namekey            |   |
+| options      | optional CSharpSymbolOptions |   |
+
+## Options
+
+|                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| accessibility         | optional [DeclaredAccessibility](../../types/declaredaccessibility/)                                                              | The accessibility of the symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| aliasTarget           | optional [OutputSymbol](../../../core/types/outputsymbol/)                                                                        | The symbol this symbol is an alias for.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| binder                | optional [Binder](../../../core/types/binder/)                                                                                    | The binder instance associated with this symbol. Symbol updates and changes will be reported to this binder. This binder will be able to find this symbol via its refkey and other means. Without a binder, this symbol will be unbound, which means it cannot be referenced by refkey. When constructing an external library symbol, pass `{ binder }` here to ensure the symbol is registered with the binder. See [TO\_SYMBOL](../../../core/variables/to_symbol/) for the full implementation protocol. |
+| ignoreNameConflict    | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name conflict resolution. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring name conflict resolution.                                                                                                                                                                                                                                                                            |
+| ignoreNamePolicy      | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name policy. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring the name policy.                                                                                                                                                                                                                                                                                                  |
+| isAbstract            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isExtern              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isNullable            | optional boolean                                                                                                                  | Whether the value held by this symbol could be null.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| isOverride            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isReadOnly            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isSealed              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isStatic              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isVirtual             | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| lazyMemberInitializer | optional () => void                                                                                                               | Provide a function which lazy-initializes members the first time `resolveMemberByName()` is called on this symbol. Called at most once. Only `resolveMemberByName()` triggers this callback — iterating `OutputMemberSpace` directly does not. The callback fires regardless of whether the symbol belongs to any scope, so it is safe to use on scopeless external library symbols.                                                                                                                        |
+| metadata              | optional Record\<string, unknown>                                                                                                 | Arbitrary metadata about this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| namePolicy            | optional [NamePolicyGetter](../../../core/types/namepolicygetter/)                                                                | When provided, this symbol will be named according to the provided name policy.                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| refkeys               | optional [Refkey](../../../core/types/refkey/) \| [Refkey](../../../core/types/refkey/)\[]                                        | The refkey or refkeys associated with this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| transient             | optional boolean                                                                                                                  | Whether this symbol is transient.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| type                  | optional [OutputSymbol](../../../core/types/outputsymbol/) \| Ref<[OutputSymbol](../../../core/types/outputsymbol/) \| undefined> | The symbol that provides type information for this symbol. When present, this symbol will not contain its own members, and instead members will be provided by the type. This can be provided a Ref, in which case the type will be the value of that ref.                                                                                                                                                                                                                                                  |
+
+## Returns
+
+[CSharpSymbol](../../types/csharpsymbol/)

package/docs/api/functions/createLibrary.md

@@ -0,0 +1,19 @@
+# createLibrary
+
+```ts
+import { createLibrary } from "@alloy-js/csharp";
+
+
+function createLibrary<T extends Record<string, Descriptor>>(rootNs: string, props: T): LibraryFrom<T>;
+```
+
+## Parameters
+
+|        |        |   |
+| ------ | ------ | - |
+| rootNs | string |   |
+| props  | T      |   |
+
+## Returns
+
+[LibraryFrom](../../types/libraryfrom/)\<T>

package/docs/api/functions/createMethodScope.md

@@ -0,0 +1,26 @@
+# createMethodScope
+
+```ts
+import { createMethodScope } from "@alloy-js/csharp";
+
+
+function createMethodScope(options?: OutputScopeOptions): CSharpMethodScope;
+```
+
+## Parameters
+
+|         |                             |   |
+| ------- | --------------------------- | - |
+| options | optional OutputScopeOptions |   |
+
+## Options
+
+|             |                                                            |                                                                                                                                                                               |
+| ----------- | ---------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| binder      | optional [Binder](../../../core/types/binder/)             | The binder instance this scope belongs to. If not provided, it will attempt to find the current binder from context.                                                          |
+| metadata    | optional Record\<string, unknown>                          | Arbitrary metadata that is associated with this scope.                                                                                                                        |
+| ownerSymbol | optional [OutputSymbol](../../../core/types/outputsymbol/) | The owner symbol of this scope. When provided, this scope becomes a member scope, which exposes the symbols on its owner symbol instead of having its own declaration spaces. |
+
+## Returns
+
+[CSharpMethodScope](../../types/csharpmethodscope/)

package/docs/api/functions/createMethodSymbol.md

@@ -0,0 +1,34 @@
+# createMethodSymbol
+
+```ts
+import { createMethodSymbol } from "@alloy-js/csharp";
+
+
+function createMethodSymbol(originalName: string | Namekey, options?: CreateMethodSymbolOptions): MethodSymbol;
+```
+
+## Parameters
+
+|              |                                    |   |
+| ------------ | ---------------------------------- | - |
+| originalName | string \| Namekey                  |   |
+| options      | optional CreateMethodSymbolOptions |   |
+
+## Options
+
+|               |                                                                      |                                                      |
+| ------------- | -------------------------------------------------------------------- | ---------------------------------------------------- |
+| accessibility | optional [DeclaredAccessibility](../../types/declaredaccessibility/) | The accessibility of the symbol.                     |
+| isAbstract    | optional boolean                                                     |                                                      |
+| isExtern      | optional boolean                                                     |                                                      |
+| isNullable    | optional boolean                                                     | Whether the value held by this symbol could be null. |
+| isOverride    | optional boolean                                                     |                                                      |
+| isReadOnly    | optional boolean                                                     |                                                      |
+| isSealed      | optional boolean                                                     |                                                      |
+| isStatic      | optional boolean                                                     |                                                      |
+| isVirtual     | optional boolean                                                     |                                                      |
+| methodKind    | optional [MethodKinds](../../types/methodkinds/)                     |                                                      |
+
+## Returns
+
+[MethodSymbol](../../types/methodsymbol/)

package/docs/api/functions/createNamedTypeScope.md

@@ -0,0 +1,27 @@
+# createNamedTypeScope
+
+```ts
+import { createNamedTypeScope } from "@alloy-js/csharp";
+
+
+function createNamedTypeScope(ownerSymbol: NamedTypeSymbol, options?: OutputScopeOptions): CSharpNamedTypeScope;
+```
+
+## Parameters
+
+|             |                             |   |
+| ----------- | --------------------------- | - |
+| ownerSymbol | NamedTypeSymbol             |   |
+| options     | optional OutputScopeOptions |   |
+
+## Options
+
+|             |                                                            |                                                                                                                                                                               |
+| ----------- | ---------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| binder      | optional [Binder](../../../core/types/binder/)             | The binder instance this scope belongs to. If not provided, it will attempt to find the current binder from context.                                                          |
+| metadata    | optional Record\<string, unknown>                          | Arbitrary metadata that is associated with this scope.                                                                                                                        |
+| ownerSymbol | optional [OutputSymbol](../../../core/types/outputsymbol/) | The owner symbol of this scope. When provided, this scope becomes a member scope, which exposes the symbols on its owner symbol instead of having its own declaration spaces. |
+
+## Returns
+
+[CSharpNamedTypeScope](../../types/csharpnamedtypescope/)

package/docs/api/functions/createNamedTypeSymbol.md

@@ -0,0 +1,35 @@
+# createNamedTypeSymbol
+
+```ts
+import { createNamedTypeSymbol } from "@alloy-js/csharp";
+
+
+function createNamedTypeSymbol(name: string | Namekey, kind: NamedTypeTypeKind, options?: OutputSymbolOptions): NamedTypeSymbol;
+```
+
+## Parameters
+
+|         |                              |   |
+| ------- | ---------------------------- | - |
+| name    | string \| Namekey            |   |
+| kind    | NamedTypeTypeKind            |   |
+| options | optional OutputSymbolOptions |   |
+
+## Options
+
+|                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| aliasTarget           | optional [OutputSymbol](../../../core/types/outputsymbol/)                                                                        | The symbol this symbol is an alias for.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| binder                | optional [Binder](../../../core/types/binder/)                                                                                    | The binder instance associated with this symbol. Symbol updates and changes will be reported to this binder. This binder will be able to find this symbol via its refkey and other means. Without a binder, this symbol will be unbound, which means it cannot be referenced by refkey. When constructing an external library symbol, pass `{ binder }` here to ensure the symbol is registered with the binder. See [TO\_SYMBOL](../../../core/variables/to_symbol/) for the full implementation protocol. |
+| ignoreNameConflict    | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name conflict resolution. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring name conflict resolution.                                                                                                                                                                                                                                                                            |
+| ignoreNamePolicy      | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name policy. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring the name policy.                                                                                                                                                                                                                                                                                                  |
+| lazyMemberInitializer | optional () => void                                                                                                               | Provide a function which lazy-initializes members the first time `resolveMemberByName()` is called on this symbol. Called at most once. Only `resolveMemberByName()` triggers this callback — iterating `OutputMemberSpace` directly does not. The callback fires regardless of whether the symbol belongs to any scope, so it is safe to use on scopeless external library symbols.                                                                                                                        |
+| metadata              | optional Record\<string, unknown>                                                                                                 | Arbitrary metadata about this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| namePolicy            | optional [NamePolicyGetter](../../../core/types/namepolicygetter/)                                                                | When provided, this symbol will be named according to the provided name policy.                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| refkeys               | optional [Refkey](../../../core/types/refkey/) \| [Refkey](../../../core/types/refkey/)\[]                                        | The refkey or refkeys associated with this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| transient             | optional boolean                                                                                                                  | Whether this symbol is transient.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| type                  | optional [OutputSymbol](../../../core/types/outputsymbol/) \| Ref<[OutputSymbol](../../../core/types/outputsymbol/) \| undefined> | The symbol that provides type information for this symbol. When present, this symbol will not contain its own members, and instead members will be provided by the type. This can be provided a Ref, in which case the type will be the value of that ref.                                                                                                                                                                                                                                                  |
+
+## Returns
+
+[NamedTypeSymbol](../../types/namedtypesymbol/)

package/docs/api/functions/createNamespaceSymbol.md

@@ -0,0 +1,43 @@
+# createNamespaceSymbol
+
+```ts
+import { createNamespaceSymbol } from "@alloy-js/csharp";
+
+
+function createNamespaceSymbol(name: string | Namekey | (string | Namekey)[], options?: CSharpSymbolOptions): NamespaceSymbol;
+```
+
+## Parameters
+
+|         |                                             |   |
+| ------- | ------------------------------------------- | - |
+| name    | string \| Namekey \| (string \| Namekey)\[] |   |
+| options | optional CSharpSymbolOptions                |   |
+
+## Options
+
+|                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| accessibility         | optional [DeclaredAccessibility](../../types/declaredaccessibility/)                                                              | The accessibility of the symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| aliasTarget           | optional [OutputSymbol](../../../core/types/outputsymbol/)                                                                        | The symbol this symbol is an alias for.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| binder                | optional [Binder](../../../core/types/binder/)                                                                                    | The binder instance associated with this symbol. Symbol updates and changes will be reported to this binder. This binder will be able to find this symbol via its refkey and other means. Without a binder, this symbol will be unbound, which means it cannot be referenced by refkey. When constructing an external library symbol, pass `{ binder }` here to ensure the symbol is registered with the binder. See [TO\_SYMBOL](../../../core/variables/to_symbol/) for the full implementation protocol. |
+| ignoreNameConflict    | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name conflict resolution. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring name conflict resolution.                                                                                                                                                                                                                                                                            |
+| ignoreNamePolicy      | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name policy. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring the name policy.                                                                                                                                                                                                                                                                                                  |
+| isAbstract            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isExtern              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isNullable            | optional boolean                                                                                                                  | Whether the value held by this symbol could be null.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| isOverride            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isReadOnly            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isSealed              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isStatic              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isVirtual             | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| lazyMemberInitializer | optional () => void                                                                                                               | Provide a function which lazy-initializes members the first time `resolveMemberByName()` is called on this symbol. Called at most once. Only `resolveMemberByName()` triggers this callback — iterating `OutputMemberSpace` directly does not. The callback fires regardless of whether the symbol belongs to any scope, so it is safe to use on scopeless external library symbols.                                                                                                                        |
+| metadata              | optional Record\<string, unknown>                                                                                                 | Arbitrary metadata about this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| namePolicy            | optional [NamePolicyGetter](../../../core/types/namepolicygetter/)                                                                | When provided, this symbol will be named according to the provided name policy.                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| refkeys               | optional [Refkey](../../../core/types/refkey/) \| [Refkey](../../../core/types/refkey/)\[]                                        | The refkey or refkeys associated with this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| transient             | optional boolean                                                                                                                  | Whether this symbol is transient.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| type                  | optional [OutputSymbol](../../../core/types/outputsymbol/) \| Ref<[OutputSymbol](../../../core/types/outputsymbol/) \| undefined> | The symbol that provides type information for this symbol. When present, this symbol will not contain its own members, and instead members will be provided by the type. This can be provided a Ref, in which case the type will be the value of that ref.                                                                                                                                                                                                                                                  |
+
+## Returns
+
+[NamespaceSymbol](../../types/namespacesymbol/)

package/docs/api/functions/createParameterSymbol.md

@@ -0,0 +1,45 @@
+# createParameterSymbol
+
+Create a symbol for a parameter in the current method scope.
+
+```ts
+import { createParameterSymbol } from "@alloy-js/csharp";
+
+
+function createParameterSymbol(originalName: string | Namekey, options?: CSharpSymbolOptions): CSharpSymbol;
+```
+
+## Parameters
+
+|              |                              |   |
+| ------------ | ---------------------------- | - |
+| originalName | string \| Namekey            |   |
+| options      | optional CSharpSymbolOptions |   |
+
+## Options
+
+|                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| accessibility         | optional [DeclaredAccessibility](../../types/declaredaccessibility/)                                                              | The accessibility of the symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| aliasTarget           | optional [OutputSymbol](../../../core/types/outputsymbol/)                                                                        | The symbol this symbol is an alias for.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| binder                | optional [Binder](../../../core/types/binder/)                                                                                    | The binder instance associated with this symbol. Symbol updates and changes will be reported to this binder. This binder will be able to find this symbol via its refkey and other means. Without a binder, this symbol will be unbound, which means it cannot be referenced by refkey. When constructing an external library symbol, pass `{ binder }` here to ensure the symbol is registered with the binder. See [TO\_SYMBOL](../../../core/variables/to_symbol/) for the full implementation protocol. |
+| ignoreNameConflict    | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name conflict resolution. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring name conflict resolution.                                                                                                                                                                                                                                                                            |
+| ignoreNamePolicy      | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name policy. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring the name policy.                                                                                                                                                                                                                                                                                                  |
+| isAbstract            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isExtern              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isNullable            | optional boolean                                                                                                                  | Whether the value held by this symbol could be null.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| isOverride            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isReadOnly            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isSealed              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isStatic              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isVirtual             | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| lazyMemberInitializer | optional () => void                                                                                                               | Provide a function which lazy-initializes members the first time `resolveMemberByName()` is called on this symbol. Called at most once. Only `resolveMemberByName()` triggers this callback — iterating `OutputMemberSpace` directly does not. The callback fires regardless of whether the symbol belongs to any scope, so it is safe to use on scopeless external library symbols.                                                                                                                        |
+| metadata              | optional Record\<string, unknown>                                                                                                 | Arbitrary metadata about this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| namePolicy            | optional [NamePolicyGetter](../../../core/types/namepolicygetter/)                                                                | When provided, this symbol will be named according to the provided name policy.                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| refkeys               | optional [Refkey](../../../core/types/refkey/) \| [Refkey](../../../core/types/refkey/)\[]                                        | The refkey or refkeys associated with this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| transient             | optional boolean                                                                                                                  | Whether this symbol is transient.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| type                  | optional [OutputSymbol](../../../core/types/outputsymbol/) \| Ref<[OutputSymbol](../../../core/types/outputsymbol/) \| undefined> | The symbol that provides type information for this symbol. When present, this symbol will not contain its own members, and instead members will be provided by the type. This can be provided a Ref, in which case the type will be the value of that ref.                                                                                                                                                                                                                                                  |
+
+## Returns
+
+[CSharpSymbol](../../types/csharpsymbol/)

package/docs/api/functions/createPropertySymbol.md

@@ -0,0 +1,43 @@
+# createPropertySymbol
+
+```ts
+import { createPropertySymbol } from "@alloy-js/csharp";
+
+
+function createPropertySymbol(name: string | Namekey, options: CSharpSymbolOptions): CSharpSymbol;
+```
+
+## Parameters
+
+|         |                     |   |
+| ------- | ------------------- | - |
+| name    | string \| Namekey   |   |
+| options | CSharpSymbolOptions |   |
+
+## Options
+
+|                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| accessibility         | optional [DeclaredAccessibility](../../types/declaredaccessibility/)                                                              | The accessibility of the symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| aliasTarget           | optional [OutputSymbol](../../../core/types/outputsymbol/)                                                                        | The symbol this symbol is an alias for.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| binder                | optional [Binder](../../../core/types/binder/)                                                                                    | The binder instance associated with this symbol. Symbol updates and changes will be reported to this binder. This binder will be able to find this symbol via its refkey and other means. Without a binder, this symbol will be unbound, which means it cannot be referenced by refkey. When constructing an external library symbol, pass `{ binder }` here to ensure the symbol is registered with the binder. See [TO\_SYMBOL](../../../core/variables/to_symbol/) for the full implementation protocol. |
+| ignoreNameConflict    | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name conflict resolution. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring name conflict resolution.                                                                                                                                                                                                                                                                            |
+| ignoreNamePolicy      | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name policy. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring the name policy.                                                                                                                                                                                                                                                                                                  |
+| isAbstract            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isExtern              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isNullable            | optional boolean                                                                                                                  | Whether the value held by this symbol could be null.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| isOverride            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isReadOnly            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isSealed              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isStatic              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isVirtual             | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| lazyMemberInitializer | optional () => void                                                                                                               | Provide a function which lazy-initializes members the first time `resolveMemberByName()` is called on this symbol. Called at most once. Only `resolveMemberByName()` triggers this callback — iterating `OutputMemberSpace` directly does not. The callback fires regardless of whether the symbol belongs to any scope, so it is safe to use on scopeless external library symbols.                                                                                                                        |
+| metadata              | optional Record\<string, unknown>                                                                                                 | Arbitrary metadata about this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| namePolicy            | optional [NamePolicyGetter](../../../core/types/namepolicygetter/)                                                                | When provided, this symbol will be named according to the provided name policy.                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| refkeys               | optional [Refkey](../../../core/types/refkey/) \| [Refkey](../../../core/types/refkey/)\[]                                        | The refkey or refkeys associated with this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| transient             | optional boolean                                                                                                                  | Whether this symbol is transient.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| type                  | optional [OutputSymbol](../../../core/types/outputsymbol/) \| Ref<[OutputSymbol](../../../core/types/outputsymbol/) \| undefined> | The symbol that provides type information for this symbol. When present, this symbol will not contain its own members, and instead members will be provided by the type. This can be provided a Ref, in which case the type will be the value of that ref.                                                                                                                                                                                                                                                  |
+
+## Returns
+
+[CSharpSymbol](../../types/csharpsymbol/)

package/docs/api/functions/createTypeParameterSymbol.md

@@ -0,0 +1,34 @@
+# createTypeParameterSymbol
+
+```ts
+import { createTypeParameterSymbol } from "@alloy-js/csharp";
+
+
+function createTypeParameterSymbol(originalName: string | Namekey, options?: CreateTypeParameterSymbolOptions): CSharpSymbol;
+```
+
+## Parameters
+
+|              |                                           |   |
+| ------------ | ----------------------------------------- | - |
+| originalName | string \| Namekey                         |   |
+| options      | optional CreateTypeParameterSymbolOptions |   |
+
+## Options
+
+|               |                                                                                                                           |                                                      |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
+| accessibility | optional [DeclaredAccessibility](../../types/declaredaccessibility/)                                                      | The accessibility of the symbol.                     |
+| isAbstract    | optional boolean                                                                                                          |                                                      |
+| isExtern      | optional boolean                                                                                                          |                                                      |
+| isNullable    | optional boolean                                                                                                          | Whether the value held by this symbol could be null. |
+| isOverride    | optional boolean                                                                                                          |                                                      |
+| isReadOnly    | optional boolean                                                                                                          |                                                      |
+| isSealed      | optional boolean                                                                                                          |                                                      |
+| isStatic      | optional boolean                                                                                                          |                                                      |
+| isVirtual     | optional boolean                                                                                                          |                                                      |
+| scope         | optional [CSharpMethodScope](../../types/csharpmethodscope/) \| [CSharpNamedTypeScope](../../types/csharpnamedtypescope/) |                                                      |
+
+## Returns
+
+[CSharpSymbol](../../types/csharpsymbol/)

package/docs/api/functions/createVariableSymbol.md

@@ -0,0 +1,43 @@
+# createVariableSymbol
+
+```ts
+import { createVariableSymbol } from "@alloy-js/csharp";
+
+
+function createVariableSymbol(originalName: string | Namekey, options?: CSharpSymbolOptions): CSharpSymbol;
+```
+
+## Parameters
+
+|              |                              |   |
+| ------------ | ---------------------------- | - |
+| originalName | string \| Namekey            |   |
+| options      | optional CSharpSymbolOptions |   |
+
+## Options
+
+|                       |                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| accessibility         | optional [DeclaredAccessibility](../../types/declaredaccessibility/)                                                              | The accessibility of the symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| aliasTarget           | optional [OutputSymbol](../../../core/types/outputsymbol/)                                                                        | The symbol this symbol is an alias for.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| binder                | optional [Binder](../../../core/types/binder/)                                                                                    | The binder instance associated with this symbol. Symbol updates and changes will be reported to this binder. This binder will be able to find this symbol via its refkey and other means. Without a binder, this symbol will be unbound, which means it cannot be referenced by refkey. When constructing an external library symbol, pass `{ binder }` here to ensure the symbol is registered with the binder. See [TO\_SYMBOL](../../../core/variables/to_symbol/) for the full implementation protocol. |
+| ignoreNameConflict    | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name conflict resolution. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring name conflict resolution.                                                                                                                                                                                                                                                                            |
+| ignoreNamePolicy      | optional boolean                                                                                                                  | Whether the name of this symbol should bypass the active name policy. When true, the name of this symbol will be fixed, though it may conflict with other symbols which are also ignoring the name policy.                                                                                                                                                                                                                                                                                                  |
+| isAbstract            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isExtern              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isNullable            | optional boolean                                                                                                                  | Whether the value held by this symbol could be null.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| isOverride            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isReadOnly            | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isSealed              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isStatic              | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| isVirtual             | optional boolean                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| lazyMemberInitializer | optional () => void                                                                                                               | Provide a function which lazy-initializes members the first time `resolveMemberByName()` is called on this symbol. Called at most once. Only `resolveMemberByName()` triggers this callback — iterating `OutputMemberSpace` directly does not. The callback fires regardless of whether the symbol belongs to any scope, so it is safe to use on scopeless external library symbols.                                                                                                                        |
+| metadata              | optional Record\<string, unknown>                                                                                                 | Arbitrary metadata about this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| namePolicy            | optional [NamePolicyGetter](../../../core/types/namepolicygetter/)                                                                | When provided, this symbol will be named according to the provided name policy.                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| refkeys               | optional [Refkey](../../../core/types/refkey/) \| [Refkey](../../../core/types/refkey/)\[]                                        | The refkey or refkeys associated with this symbol.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| transient             | optional boolean                                                                                                                  | Whether this symbol is transient.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| type                  | optional [OutputSymbol](../../../core/types/outputsymbol/) \| Ref<[OutputSymbol](../../../core/types/outputsymbol/) \| undefined> | The symbol that provides type information for this symbol. When present, this symbol will not contain its own members, and instead members will be provided by the type. This can be provided a Ref, in which case the type will be the value of that ref.                                                                                                                                                                                                                                                  |
+
+## Returns
+
+[CSharpSymbol](../../types/csharpsymbol/)

package/docs/api/functions/getAccessModifier.md

@@ -0,0 +1,18 @@
+# getAccessModifier
+
+```ts
+import { getAccessModifier } from "@alloy-js/csharp";
+
+
+getAccessModifier: (data: AccessModifiers) => string
+```
+
+## Parameters
+
+|      |                 |   |
+| ---- | --------------- | - |
+| data | AccessModifiers |   |
+
+## Returns
+
+string

package/docs/api/functions/getAsyncModifier.md

@@ -0,0 +1,18 @@
+# getAsyncModifier
+
+```ts
+import { getAsyncModifier } from "@alloy-js/csharp";
+
+
+function getAsyncModifier(async?: boolean): string;
+```
+
+## Parameters
+
+|       |                  |   |
+| ----- | ---------------- | - |
+| async | optional boolean |   |
+
+## Returns
+
+string

package/docs/api/functions/index.md

@@ -0,0 +1,33 @@
+# csharp — functions
+
+- [access](access.md) — import { access } from "@alloy-js/csharp";
+- [accessibilityFromProps](accessibilityFromProps.md) — import { accessibilityFromProps } from "@alloy-js/csharp";
+- [computeModifiersPrefix](computeModifiersPrefix.md) — Resolve the modifier prefix
+- [createClassScope](createClassScope.md) — import { createClassScope } from "@alloy-js/csharp";
+- [createCSharpNamePolicy](createCSharpNamePolicy.md) — import { createCSharpNamePolicy } from "@alloy-js/csharp";
+- [createCSharpNamespaceScope](createCSharpNamespaceScope.md) — import { createCSharpNamespaceScope } from "@alloy-js/csharp";
+- [createFieldSymbol](createFieldSymbol.md) — import { createFieldSymbol } from "@alloy-js/csharp";
+- [createLibrary](createLibrary.md) — import { createLibrary } from "@alloy-js/csharp";
+- [createMethodScope](createMethodScope.md) — import { createMethodScope } from "@alloy-js/csharp";
+- [createMethodSymbol](createMethodSymbol.md) — import { createMethodSymbol } from "@alloy-js/csharp";
+- [createNamedTypeScope](createNamedTypeScope.md) — import { createNamedTypeScope } from "@alloy-js/csharp";
+- [createNamedTypeSymbol](createNamedTypeSymbol.md) — import { createNamedTypeSymbol } from "@alloy-js/csharp";
+- [createNamespaceSymbol](createNamespaceSymbol.md) — import { createNamespaceSymbol } from "@alloy-js/csharp";
+- [createParameterSymbol](createParameterSymbol.md) — Create a symbol for a parameter in the current method scope.
+- [createPropertySymbol](createPropertySymbol.md) — import { createPropertySymbol } from "@alloy-js/csharp";
+- [createTypeParameterSymbol](createTypeParameterSymbol.md) — import { createTypeParameterSymbol } from "@alloy-js/csharp";
+- [createVariableSymbol](createVariableSymbol.md) — import { createVariableSymbol } from "@alloy-js/csharp";
+- [getAccessModifier](getAccessModifier.md) — import { getAccessModifier } from "@alloy-js/csharp";
+- [getAsyncModifier](getAsyncModifier.md) — import { getAsyncModifier } from "@alloy-js/csharp";
+- [makeModifiers](makeModifiers.md) — import { makeModifiers } from "@alloy-js/csharp";
+- [nonAccessibilityFromProps](nonAccessibilityFromProps.md) — import { nonAccessibilityFromProps } from "@alloy-js/csharp";
+- [ref](ref.md) — import { ref } from "@alloy-js/csharp";
+- [useCsharpFormatOptions](useCsharpFormatOptions.md) — import { useCsharpFormatOptions } from "@alloy-js/csharp";
+- [useCSharpNamePolicy](useCSharpNamePolicy.md) — import { useCSharpNamePolicy } from "@alloy-js/csharp";
+- [useCSharpScope](useCSharpScope.md) — import { useCSharpScope } from "@alloy-js/csharp";
+- [useEnclosingNamespaceScope](useEnclosingNamespaceScope.md) — import { useEnclosingNamespaceScope } from "@alloy-js/csharp";
+- [useLexicalScope](useLexicalScope.md) — import { useLexicalScope } from "@alloy-js/csharp";
+- [useMethodScope](useMethodScope.md) — import { useMethodScope } from "@alloy-js/csharp";
+- [useNamedTypeScope](useNamedTypeScope.md) — import { useNamedTypeScope } from "@alloy-js/csharp";
+- [useNamespace](useNamespace.md) — import { useNamespace } from "@alloy-js/csharp";
+- [useSourceFileScope](useSourceFileScope.md) — import { useSourceFileScope } from "@alloy-js/csharp";