@alloy-js/csharp 0.23.0-dev.1 → 0.23.0-dev.10

package/docs/api/components/RecordDeclaration.md

@@ -0,0 +1,84 @@
+# RecordDeclaration
+
+CSharp record declaration.
+
+Props to use the [RecordDeclaration](../recorddeclaration/) component
+
+* jsx
+
+  ```tsx
+  import { RecordDeclaration } from "@alloy-js/csharp";
+
+
+  <RecordDeclaration
+    doc={core.Children}
+    file
+    internal
+    name={string | core.Namekey}
+    partial
+    primaryConstructor={ParameterProps[]}
+    private
+    protected
+    public
+    refkey={core.Refkey}
+    typeParameters={Record<string, core.Refkey>}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { RecordDeclaration } from "@alloy-js/csharp/stc";
+
+
+  RecordDeclaration({
+    doc: core.Children,
+    file: boolean,
+    internal: boolean,
+    name: string | core.Namekey,
+    partial: boolean,
+    primaryConstructor: ParameterProps[],
+    private: boolean,
+    protected: boolean,
+    public: boolean,
+    refkey: core.Refkey,
+    typeParameters: Record<string, core.Refkey>,
+  }).children(children)
+  ```
+
+## Props
+
+|                    |                                                                 |                                        |
+| ------------------ | --------------------------------------------------------------- | -------------------------------------- |
+| doc                | optional [Children](../../../core/types/children/)              | Doc comment                            |
+| file               | optional boolean                                                |                                        |
+| internal           | optional boolean                                                |                                        |
+| name               | string \| [Namekey](../../../core/types/namekey/)               |                                        |
+| partial            | optional boolean                                                |                                        |
+| primaryConstructor | optional [ParameterProps](../parameter/)\[]                     | Set the primary constructor parameters |
+| private            | optional boolean                                                |                                        |
+| protected          | optional boolean                                                |                                        |
+| public             | optional boolean                                                |                                        |
+| refkey             | optional [Refkey](../../../core/types/refkey/)                  |                                        |
+| typeParameters     | optional Record\<string, [Refkey](../../../core/types/refkey/)> |                                        |
+
+## Example
+
+```tsx
+<RecordDeclaration public name="IMyRecord">
+  <RecordMember public name="MyProperty" type="int" />
+  <RecordMethod public name="MyMethod" returnType="void">
+    <Parameter name="value" type="int" />
+  </RecordMethod>
+</RecordDeclaration>
+```
+
+This will produce:
+
+```csharp
+public record MyIface
+{
+  public int MyProperty { get; set; }
+  public void MyMethod(int value);
+}
+```

package/docs/api/components/Reference.md

@@ -0,0 +1,25 @@
+# Reference
+
+* jsx
+
+  ```tsx
+  import { Reference } from "@alloy-js/csharp";
+
+
+  <Reference refkey={core.Refkey} />
+  ```
+
+* stc
+
+  ```ts
+  import { Reference } from "@alloy-js/csharp/stc";
+
+
+  Reference({ refkey: core.Refkey }).children(children)
+  ```
+
+## Props
+
+|        |                                       |   |
+| ------ | ------------------------------------- | - |
+| refkey | [Refkey](../../../core/types/refkey/) |   |

package/docs/api/components/Region.md

@@ -0,0 +1,28 @@
+# Region
+
+* jsx
+
+  ```tsx
+  import { Region } from "@alloy-js/csharp";
+
+
+  <Region name="string">
+    {children}
+  </Region>
+  ```
+
+* stc
+
+  ```ts
+  import { Region } from "@alloy-js/csharp/stc";
+
+
+  Region({ name: string }).children(children)
+  ```
+
+## Props
+
+|          |                                           |   |
+| -------- | ----------------------------------------- | - |
+| children | [Children](../../../core/types/children/) |   |
+| name     | string                                    |   |

package/docs/api/components/SourceFile.md

@@ -0,0 +1,45 @@
+# SourceFile
+
+A C# source file exists within the context of a namespace contains using statements and declarations
+
+Props for [SourceFile](../sourcefile/) component
+
+* jsx
+
+  ```tsx
+  import { SourceFile } from "@alloy-js/csharp";
+
+
+  <SourceFile
+    header={Children}
+    headerComment="string"
+    path="string"
+    using={string[]}
+  >
+    {children}
+  </SourceFile>
+  ```
+
+* stc
+
+  ```ts
+  import { SourceFile } from "@alloy-js/csharp/stc";
+
+
+  SourceFile({
+    header: Children,
+    headerComment: string,
+    path: string,
+    using: string[],
+  }).children(children)
+  ```
+
+## Props
+
+|               |                                                    |                                                                                                                                              |
+| ------------- | -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| children      | optional [Children](../../../core/types/children/) | Source file content                                                                                                                          |
+| header        | optional [Children](../../../core/types/children/) |                                                                                                                                              |
+| headerComment | optional string                                    |                                                                                                                                              |
+| path          | string                                             | Path of the source file                                                                                                                      |
+| using         | optional string\[]                                 | A list of using directives to explicitly include. Note that providing explicit usings is not necessary when referencing symbols via refkeys. |

package/docs/api/components/StructDeclaration.md

@@ -0,0 +1,94 @@
+# StructDeclaration
+
+CSharp struct declaration.
+
+* jsx
+
+  ```tsx
+  import { StructDeclaration } from "@alloy-js/csharp";
+
+
+  <StructDeclaration
+    attributes={AttributesProp}
+    doc={core.Children}
+    file
+    interfaceTypes={core.Children[]}
+    internal
+    name={string | core.Namekey}
+    new
+    partial
+    private
+    protected
+    public
+    readonly
+    ref
+    refkey={core.Refkey}
+    typeParameters={(TypeParameterProps | string)[]}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { StructDeclaration } from "@alloy-js/csharp/stc";
+
+
+  StructDeclaration({
+    attributes: AttributesProp,
+    doc: core.Children,
+    file: boolean,
+    interfaceTypes: core.Children[],
+    internal: boolean,
+    name: string | core.Namekey,
+    new: boolean,
+    partial: boolean,
+    private: boolean,
+    protected: boolean,
+    public: boolean,
+    readonly: boolean,
+    ref: boolean,
+    refkey: core.Refkey,
+    typeParameters: (TypeParameterProps | string)[],
+  }).children(children)
+  ```
+
+## Props
+
+|                |                                                                               |                                   |
+| -------------- | ----------------------------------------------------------------------------- | --------------------------------- |
+| attributes     | optional [AttributesProp](../../types/attributesprop/)                        | Define attributes to attach       |
+| doc            | optional [Children](../../../core/types/children/)                            | Doc comment                       |
+| file           | optional boolean                                                              |                                   |
+| interfaceTypes | optional [Children](../../../core/types/children/)\[]                         | Interfaces this struct implements |
+| internal       | optional boolean                                                              |                                   |
+| name           | string \| [Namekey](../../../core/types/namekey/)                             |                                   |
+| new            | optional boolean                                                              |                                   |
+| partial        | optional boolean                                                              |                                   |
+| private        | optional boolean                                                              |                                   |
+| protected      | optional boolean                                                              |                                   |
+| public         | optional boolean                                                              |                                   |
+| readonly       | optional boolean                                                              |                                   |
+| ref            | optional boolean                                                              |                                   |
+| refkey         | optional [Refkey](../../../core/types/refkey/)                                |                                   |
+| typeParameters | optional ([TypeParameterProps](../../types/typeparameterprops/) \| string)\[] | Type parameters for the struct    |
+
+## Example
+
+```tsx
+<StructDeclaration public name="IMyStruct">
+  <StructMember public name="MyProperty" type="int" />
+  <StructMethod public name="MyMethod" returnType="void">
+    <Parameter name="value" type="int" />
+  </StructMethod>
+</StructDeclaration>
+```
+
+This will produce:
+
+```csharp
+public struct MyIface
+{
+  public int MyProperty { get; set; }
+  public void MyMethod(int value);
+}
+```

package/docs/api/components/UsingNamespaceDirective.md

@@ -0,0 +1,25 @@
+# UsingNamespaceDirective
+
+* jsx
+
+  ```tsx
+  import { UsingNamespaceDirective } from "@alloy-js/csharp";
+
+
+  <UsingNamespaceDirective namespace="string" />
+  ```
+
+* stc
+
+  ```ts
+  import { UsingNamespaceDirective } from "@alloy-js/csharp/stc";
+
+
+  UsingNamespaceDirective({ namespace: string }).children(children)
+  ```
+
+## Props
+
+|           |        |   |
+| --------- | ------ | - |
+| namespace | string |   |

package/docs/api/components/Usings.md

@@ -0,0 +1,40 @@
+# Usings
+
+Component rendering csharp using directive
+
+* jsx
+
+  ```tsx
+  import { Usings } from "@alloy-js/csharp";
+
+
+  <Usings namespaces={(NamespaceSymbol | string)[]} />
+  ```
+
+* stc
+
+  ```ts
+  import { Usings } from "@alloy-js/csharp/stc";
+
+
+  Usings({ namespaces: (NamespaceSymbol | string)[] }).children(children)
+  ```
+
+## Props
+
+|            |                                                                |                                                                           |
+| ---------- | -------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| namespaces | ([NamespaceSymbol](../../types/namespacesymbol/) \| string)\[] | Namespace symbols or namespace names to use to generate using statements. |
+
+## Example
+
+```tsx
+<Usings namespaces={["System", "Models"]} />
+```
+
+will render
+
+```csharp
+using Models;
+using System;
+```

package/docs/api/components/VarDeclaration.md

@@ -0,0 +1,74 @@
+# VarDeclaration
+
+Render a variable declaration
+
+Props for [VarDeclaration](../vardeclaration/) component
+
+* jsx
+
+  ```tsx
+  import { VarDeclaration } from "@alloy-js/csharp";
+
+
+  <VarDeclaration
+    const
+    name={string | Namekey}
+    refkey={Refkey}
+    type={Children}
+    using
+  >
+    {children}
+  </VarDeclaration>
+  ```
+
+* stc
+
+  ```ts
+  import { VarDeclaration } from "@alloy-js/csharp/stc";
+
+
+  VarDeclaration({
+    const: boolean,
+    name: string | Namekey,
+    refkey: Refkey,
+    type: Children,
+    using: boolean,
+  }).children(children)
+  ```
+
+## Props
+
+|          |                                                    |                                                                       |
+| -------- | -------------------------------------------------- | --------------------------------------------------------------------- |
+| children | optional [Children](../../../core/types/children/) | Variable value                                                        |
+| const    | optional boolean                                   | Constant variable. Add the const modifier.                            |
+| name     | string \| [Namekey](../../../core/types/namekey/)  | Variable name                                                         |
+| refkey   | optional [Refkey](../../../core/types/refkey/)     | Variable refkey                                                       |
+| type     | optional [Children](../../../core/types/children/) | Type of the variable declaration. If not specified, defaults to “var” |
+| using    | optional boolean                                   | Disposable variable. Add the using modifier.                          |
+
+## Examples
+
+with var
+
+```tsx
+<VarDeclaration name="myVar">42</VarDeclaration>
+```
+
+This will render:
+
+```csharp
+var myVar = 42;
+```
+
+with type
+
+```tsx
+<VarDeclaration name="myVar" type="int">42</VarDeclaration>
+```
+
+This will render:
+
+```csharp
+int myVar = 42;
+```

package/docs/api/components/index.md

@@ -0,0 +1,55 @@
+# csharp — components
+
+- [AttributeList](AttributeList.md) — Render each attributes in a new line.
+- [ClassDeclaration](ClassDeclaration.md) — CSharp class declaration.
+- [Constructor](Constructor.md) — Properties for [Constructor](../constructor/) component.
+- [CsprojFile](CsprojFile.md) — Create a .csproj file
+- [Declaration](Declaration.md) — import { Declaration } from "@alloy-js/csharp";
+- [DocC](DocC.md) — import { DocC } from "@alloy-js/csharp";
+- [DocCode](DocCode.md) — import { DocCode } from "@alloy-js/csharp";
+- [DocComment](DocComment.md) — import { DocComment } from "@alloy-js/csharp";
+- [DocDescription](DocDescription.md) — import { DocDescription } from "@alloy-js/csharp";
+- [DocExample](DocExample.md) — import { DocExample } from "@alloy-js/csharp";
+- [DocException](DocException.md) — import { DocException } from "@alloy-js/csharp";
+- [DocFromMarkdown](DocFromMarkdown.md) — Convert markdown to a Csharp doc comment
+- [DocInclude](DocInclude.md) — import { DocInclude } from "@alloy-js/csharp";
+- [DocList](DocList.md) — import { DocList } from "@alloy-js/csharp";
+- [DocPara](DocPara.md) — import { DocPara } from "@alloy-js/csharp";
+- [DocParam](DocParam.md) — import { DocParam } from "@alloy-js/csharp";
+- [DocParamRef](DocParamRef.md) — import { DocParamRef } from "@alloy-js/csharp";
+- [DocPermission](DocPermission.md) — import { DocPermission } from "@alloy-js/csharp";
+- [DocRemarks](DocRemarks.md) — import { DocRemarks } from "@alloy-js/csharp";
+- [DocReturns](DocReturns.md) — import { DocReturns } from "@alloy-js/csharp";
+- [DocSee](DocSee.md) — import { DocSee } from "@alloy-js/csharp";
+- [DocSeeAlso](DocSeeAlso.md) — import { DocSeeAlso } from "@alloy-js/csharp";
+- [DocSummary](DocSummary.md) — import { DocSummary } from "@alloy-js/csharp";
+- [DocTypeParam](DocTypeParam.md) — import { DocTypeParam } from "@alloy-js/csharp";
+- [DocTypeParamRef](DocTypeParamRef.md) — import { DocTypeParamRef } from "@alloy-js/csharp";
+- [DocValue](DocValue.md) — import { DocValue } from "@alloy-js/csharp";
+- [DocWhen](DocWhen.md) — Conditionally render the given doc in a component and tail with a line
+- [ElseClause](ElseClause.md) — The else clause of an if statement.
+- [ElseIfClause](ElseIfClause.md) — An else clause with an if statement.
+- [EnumDeclaration](EnumDeclaration.md) — A C# enum declaration
+- [EnumMember](EnumMember.md) — import { EnumMember } from "@alloy-js/csharp";
+- [Field](Field.md) — Render a c# field
+- [IfStatement](IfStatement.md) — An if statement.
+- [InterfaceDeclaration](InterfaceDeclaration.md) — CSharp interface declaration.
+- [InterfaceMethod](InterfaceMethod.md) — import { InterfaceMethod } from "@alloy-js/csharp";
+- [InterfaceProperty](InterfaceProperty.md) — Render a C# interface property.
+- [InvocationExpression](InvocationExpression.md) — A call to a function or method.
+- [LexicalScope](LexicalScope.md) — import { LexicalScope } from "@alloy-js/csharp";
+- [Method](Method.md) — import { Method } from "@alloy-js/csharp";
+- [MethodScope](MethodScope.md) — import { MethodScope } from "@alloy-js/csharp";
+- [Name](Name.md) — import { Name } from "@alloy-js/csharp";
+- [Namespace](Namespace.md) — import { Namespace } from "@alloy-js/csharp";
+- [Parameter](Parameter.md) — Define a parameter to be used in class or interface method.
+- [Parameters_2](Parameters_2.md) — Render a collection of parameters
+- [Property](Property.md) — Render a C# class property.
+- [RecordDeclaration](RecordDeclaration.md) — CSharp record declaration.
+- [Reference](Reference.md) — import { Reference } from "@alloy-js/csharp";
+- [Region](Region.md) — import { Region } from "@alloy-js/csharp";
+- [SourceFile](SourceFile.md) — A C# source file exists within the context of a namespace contains using statements and declarations
+- [StructDeclaration](StructDeclaration.md) — CSharp struct declaration.
+- [UsingNamespaceDirective](UsingNamespaceDirective.md) — import { UsingNamespaceDirective } from "@alloy-js/csharp";
+- [Usings](Usings.md) — Component rendering csharp using directive
+- [VarDeclaration](VarDeclaration.md) — Render a variable declaration

package/docs/api/functions/access.md

@@ -0,0 +1,35 @@
+# access
+
+```ts
+import { access } from "@alloy-js/csharp";
+
+
+function access(base: Refkeyable | string, options?: AccessExpressionPartProps): AccessExpressionBuilder;
+```
+
+## Parameters
+
+|         |                                    |   |
+| ------- | ---------------------------------- | - |
+| base    | Refkeyable \| string               |   |
+| options | optional AccessExpressionPartProps |   |
+
+## Options
+
+|             |                                                                  |                                                                                                                                                                                                                           |
+| ----------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| args        | optional boolean \| [Children](../../../core/types/children/)\[] | Emit a function call.                                                                                                                                                                                                     |
+| attribute   | optional boolean                                                 | Wether this part is an attribute reference (used in an attribute context). In that case the “Attribute” suffix is trimmed from the name if present.                                                                       |
+| children    | optional [Children](../../../core/types/children/)               |                                                                                                                                                                                                                           |
+| conditional | optional boolean                                                 | Whether this part should use conditional access.                                                                                                                                                                          |
+| id          | optional string                                                  | The identifier to use for this part.                                                                                                                                                                                      |
+| index       | optional [Children](../../../core/types/children/)               | Create an element access part with a single indexer argument. Mutually exclusive with the `indexerArgs` prop.                                                                                                             |
+| indexerArgs | optional [Children](../../../core/types/children/)\[]            | Create an element access part with multiple indexer arguments. Mutually exclusive with the `index` prop.                                                                                                                  |
+| nullable    | optional boolean                                                 | Whether this part could possibly be null. Will guard member and element access with a conditional access operator. Passing this is not necessary if you provide a symbol or refkey and the symbol’s nullable flag is set. |
+| refkey      | optional [Refkeyable](../../../core/types/refkeyable/)           | A refkey for the symbol whose name becomes this part’s identifier. When a refkey is provided for the first part, it will be fully resolved. Otherwise, just the symbol’s name is used.                                    |
+| symbol      | optional [CSharpSymbol](../../types/csharpsymbol/)               | The symbol whose name becomes this part’s identifier.                                                                                                                                                                     |
+| typeArgs    | optional [Children](../../../core/types/children/)\[]            | Type arguments to pass to a member access.                                                                                                                                                                                |
+
+## Returns
+
+[AccessExpressionBuilder](../../types/accessexpressionbuilder/)

package/docs/api/functions/accessibilityFromProps.md

@@ -0,0 +1,18 @@
+# accessibilityFromProps
+
+```ts
+import { accessibilityFromProps } from "@alloy-js/csharp";
+
+
+function accessibilityFromProps(props: AccessModifiers): "public" | "protected" | "private" | "internal";
+```
+
+## Parameters
+
+|       |                 |   |
+| ----- | --------------- | - |
+| props | AccessModifiers |   |
+
+## Returns
+
+“public” | “protected” | “private” | “internal”

package/docs/api/functions/computeModifiersPrefix.md

@@ -0,0 +1,20 @@
+# computeModifiersPrefix
+
+Resolve the modifier prefix
+
+```ts
+import { computeModifiersPrefix } from "@alloy-js/csharp";
+
+
+function computeModifiersPrefix(modifiers: Array<string | undefined>): string;
+```
+
+## Parameters
+
+|           |                             |   |
+| --------- | --------------------------- | - |
+| modifiers | Array\<string \| undefined> |   |
+
+## Returns
+
+string

package/docs/api/functions/createCSharpNamePolicy.md

@@ -0,0 +1,17 @@
+# createCSharpNamePolicy
+
+```ts
+import { createCSharpNamePolicy } from "@alloy-js/csharp";
+
+
+function createCSharpNamePolicy(): core.NamePolicy<CSharpElements>;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+[NamePolicy](../../../core/types/namepolicy/)<[CSharpElements](../../types/csharpelements/)>

package/docs/api/functions/createCSharpNamespaceScope.md

@@ -0,0 +1,18 @@
+# createCSharpNamespaceScope
+
+```ts
+import { createCSharpNamespaceScope } from "@alloy-js/csharp";
+
+
+function createCSharpNamespaceScope(namespaceSymbol: NamespaceSymbol): CSharpNamespaceScope;
+```
+
+## Parameters
+
+|                 |                 |   |
+| --------------- | --------------- | - |
+| namespaceSymbol | NamespaceSymbol |   |
+
+## Returns
+
+[CSharpNamespaceScope](../../types/csharpnamespacescope/)

package/docs/api/functions/createClassScope.md

@@ -0,0 +1,27 @@
+# createClassScope
+
+```ts
+import { createClassScope } from "@alloy-js/csharp";
+
+
+function createClassScope(ownerSymbol: NamedTypeSymbol, options?: OutputScopeOptions): CSharpClassScope;
+```
+
+## 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
+
+[CSharpClassScope](../../types/csharpclassscope/)