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

package/docs/api/components/InterfaceProperty.md

@@ -0,0 +1,78 @@
+# InterfaceProperty
+
+Render a C# interface property.
+
+* jsx
+
+  ```tsx
+  import { InterfaceProperty } from "@alloy-js/csharp";
+
+
+  <InterfaceProperty
+    attributes={AttributesProp}
+    doc={Children}
+    file
+    get
+    internal
+    name={string | Namekey}
+    new
+    nullable
+    private
+    protected
+    public
+    refkey={Refkey}
+    set
+    type={Children}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { InterfaceProperty } from "@alloy-js/csharp/stc";
+
+
+  InterfaceProperty({
+    attributes: AttributesProp,
+    doc: Children,
+    file: boolean,
+    get: boolean,
+    internal: boolean,
+    name: string | Namekey,
+    new: boolean,
+    nullable: boolean,
+    private: boolean,
+    protected: boolean,
+    public: boolean,
+    refkey: Refkey,
+    set: boolean,
+    type: Children,
+  }).children(children)
+  ```
+
+## Props
+
+|            |                                                        |                                  |
+| ---------- | ------------------------------------------------------ | -------------------------------- |
+| attributes | optional [AttributesProp](../../types/attributesprop/) | Define attributes to attach      |
+| doc        | optional [Children](../../../core/types/children/)     | Doc comment                      |
+| file       | optional boolean                                       |                                  |
+| get        | optional boolean                                       | If property should have a getter |
+| internal   | optional boolean                                       |                                  |
+| name       | string \| [Namekey](../../../core/types/namekey/)      |                                  |
+| new        | optional boolean                                       |                                  |
+| nullable   | optional boolean                                       | Property initializer             |
+| private    | optional boolean                                       |                                  |
+| protected  | optional boolean                                       |                                  |
+| public     | optional boolean                                       |                                  |
+| refkey     | optional [Refkey](../../../core/types/refkey/)         |                                  |
+| set        | optional boolean                                       | If property should have a setter |
+| type       | [Children](../../../core/types/children/)              | Property type                    |
+
+## Example
+
+`<InterfaceProperty public name="My" get set />`
+
+```cs
+public int My { get; set; };
+```

package/docs/api/components/InvocationExpression.md

@@ -0,0 +1,49 @@
+# InvocationExpression
+
+A call to a function or method.
+
+* jsx
+
+  ```tsx
+  import { InvocationExpression } from "@alloy-js/csharp";
+
+
+  <InvocationExpression
+    args={Children[]}
+    target={Children}
+    typeArgs={Children[]}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { InvocationExpression } from "@alloy-js/csharp/stc";
+
+
+  InvocationExpression({
+    args: Children[],
+    target: Children,
+    typeArgs: Children[],
+  }).children(children)
+  ```
+
+## Props
+
+|          |                                                       |                                            |
+| -------- | ----------------------------------------------------- | ------------------------------------------ |
+| args     | optional [Children](../../../core/types/children/)\[] | Arguments to pass to the invocation.       |
+| target   | [Children](../../../core/types/children/)             |                                            |
+| typeArgs | optional [Children](../../../core/types/children/)\[] | Generic type arguments for the invocation. |
+
+## Example
+
+```jsx
+<InvocationExpression target="Foo" typeArgs={["T"]} args={["x"]} />
+```
+
+Renders to:
+
+```csharp
+Foo<T>("x");
+```

package/docs/api/components/LexicalScope.md

@@ -0,0 +1,65 @@
+# LexicalScope
+
+## Overload 1
+
+* jsx
+
+  ```tsx
+  import { LexicalScope } from "@alloy-js/csharp";
+
+
+  <LexicalScope value={OutputScope} />
+  ```
+
+* stc
+
+  ```ts
+  import { LexicalScope } from "@alloy-js/csharp/stc";
+
+
+  LexicalScope({ value: OutputScope }).children(children)
+  ```
+
+### Props
+
+|          |                                                    |                                                                 |
+| -------- | -------------------------------------------------- | --------------------------------------------------------------- |
+| children | optional [Children](../../../core/types/children/) |                                                                 |
+| value    | [OutputScope](../../../core/types/outputscope/)    | The scope to use. If not provided, a new scope will be created. |
+
+## Overload 2
+
+* jsx
+
+  ```tsx
+  import { LexicalScope } from "@alloy-js/csharp";
+
+
+  <LexicalScope
+    metadata={Record<string, unknown>}
+    name="string"
+    ownerSymbol={OutputSymbol}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { LexicalScope } from "@alloy-js/csharp/stc";
+
+
+  LexicalScope({
+    metadata: Record<string, unknown>,
+    name: string,
+    ownerSymbol: OutputSymbol,
+  }).children(children)
+  ```
+
+### Props
+
+|             |                                                            |                                                                             |
+| ----------- | ---------------------------------------------------------- | --------------------------------------------------------------------------- |
+| children    | optional [Children](../../../core/types/children/)         |                                                                             |
+| metadata    | optional Record\<string, unknown>                          | Additional metadata for the scope.                                          |
+| name        | optional string                                            | The name of this scope.                                                     |
+| ownerSymbol | optional [OutputSymbol](../../../core/types/outputsymbol/) | Create a member scope with the owner symbol providing the in-scope symbols. |

package/docs/api/components/Method.md

@@ -0,0 +1,92 @@
+# Method
+
+* jsx
+
+  ```tsx
+  import { Method } from "@alloy-js/csharp";
+
+
+  <Method
+    abstract
+    async
+    attributes={AttributesProp}
+    doc={Children}
+    expression
+    extern
+    file
+    internal
+    name={string | Namekey}
+    override
+    parameters={Array<ParameterProps>}
+    private
+    protected
+    public
+    readonly
+    refkey={Refkey}
+    returns={Children}
+    sealed
+    static
+    typeParameters={(TypeParameterProps | string)[]}
+    virtual
+  >
+    {children}
+  </Method>
+  ```
+
+* stc
+
+  ```ts
+  import { Method } from "@alloy-js/csharp/stc";
+
+
+  Method({
+    abstract: boolean,
+    async: boolean,
+    attributes: AttributesProp,
+    doc: Children,
+    expression: boolean,
+    extern: boolean,
+    file: boolean,
+    internal: boolean,
+    name: string | Namekey,
+    override: boolean,
+    parameters: Array<ParameterProps>,
+    private: boolean,
+    protected: boolean,
+    public: boolean,
+    readonly: boolean,
+    refkey: Refkey,
+    returns: Children,
+    sealed: boolean,
+    static: boolean,
+    typeParameters: (TypeParameterProps | string)[],
+    virtual: boolean,
+  }).children(children)
+  ```
+
+## Props
+
+|                |                                                                               |                                                          |
+| -------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------- |
+| abstract       | optional boolean                                                              |                                                          |
+| async          | optional boolean                                                              | If true, the method will be declared as an async method. |
+| attributes     | optional [AttributesProp](../../types/attributesprop/)                        | Define attributes to attach                              |
+| children       | optional [Children](../../../core/types/children/)                            |                                                          |
+| doc            | optional [Children](../../../core/types/children/)                            | Doc comment                                              |
+| expression     | optional boolean                                                              | Use expression syntax for the method.                    |
+| extern         | optional boolean                                                              |                                                          |
+| file           | optional boolean                                                              |                                                          |
+| internal       | optional boolean                                                              |                                                          |
+| name           | string \| [Namekey](../../../core/types/namekey/)                             |                                                          |
+| override       | optional boolean                                                              |                                                          |
+| parameters     | optional Array<[ParameterProps](../parameter/)>                               | An array of parameter descriptors.                       |
+| private        | optional boolean                                                              |                                                          |
+| protected      | optional boolean                                                              |                                                          |
+| public         | optional boolean                                                              |                                                          |
+| readonly       | optional boolean                                                              |                                                          |
+| refkey         | optional [Refkey](../../../core/types/refkey/)                                |                                                          |
+| returns        | optional [Children](../../../core/types/children/)                            |                                                          |
+| sealed         | optional boolean                                                              |                                                          |
+| static         | optional boolean                                                              |                                                          |
+| typeParameters | optional ([TypeParameterProps](../../types/typeparameterprops/) \| string)\[] | Type parameters for the method                           |
+| virtual        | optional boolean                                                              |                                                          |

package/docs/api/components/MethodScope.md

@@ -0,0 +1,65 @@
+# MethodScope
+
+## Overload 1
+
+* jsx
+
+  ```tsx
+  import { MethodScope } from "@alloy-js/csharp";
+
+
+  <MethodScope value={OutputScope} />
+  ```
+
+* stc
+
+  ```ts
+  import { MethodScope } from "@alloy-js/csharp/stc";
+
+
+  MethodScope({ value: OutputScope }).children(children)
+  ```
+
+### Props
+
+|          |                                                    |                                                                 |
+| -------- | -------------------------------------------------- | --------------------------------------------------------------- |
+| children | optional [Children](../../../core/types/children/) |                                                                 |
+| value    | [OutputScope](../../../core/types/outputscope/)    | The scope to use. If not provided, a new scope will be created. |
+
+## Overload 2
+
+* jsx
+
+  ```tsx
+  import { MethodScope } from "@alloy-js/csharp";
+
+
+  <MethodScope
+    metadata={Record<string, unknown>}
+    name="string"
+    ownerSymbol={OutputSymbol}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { MethodScope } from "@alloy-js/csharp/stc";
+
+
+  MethodScope({
+    metadata: Record<string, unknown>,
+    name: string,
+    ownerSymbol: OutputSymbol,
+  }).children(children)
+  ```
+
+### Props
+
+|             |                                                            |                                                                             |
+| ----------- | ---------------------------------------------------------- | --------------------------------------------------------------------------- |
+| children    | optional [Children](../../../core/types/children/)         |                                                                             |
+| metadata    | optional Record\<string, unknown>                          | Additional metadata for the scope.                                          |
+| name        | optional string                                            | The name of this scope.                                                     |
+| ownerSymbol | optional [OutputSymbol](../../../core/types/outputsymbol/) | Create a member scope with the owner symbol providing the in-scope symbols. |

package/docs/api/components/Name.md

@@ -0,0 +1,19 @@
+# Name
+
+* jsx
+
+  ```tsx
+  import { Name } from "@alloy-js/csharp";
+
+
+  <Name />
+  ```
+
+* stc
+
+  ```ts
+  import { Name } from "@alloy-js/csharp/stc";
+
+
+  Name({ }).children(children)
+  ```

package/docs/api/components/Namespace.md

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

package/docs/api/components/Parameter.md

@@ -0,0 +1,58 @@
+# Parameter
+
+Define a parameter to be used in class or interface method.
+
+* jsx
+
+  ```tsx
+  import { Parameter } from "@alloy-js/csharp";
+
+
+  <Parameter
+    attributes={AttributesProp}
+    default={Children}
+    in
+    name={string | Namekey}
+    optional
+    out
+    ref
+    refReadonly
+    refkey={Refkey}
+    type={Children}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { Parameter } from "@alloy-js/csharp/stc";
+
+
+  Parameter({
+    attributes: AttributesProp,
+    default: Children,
+    in: boolean,
+    name: string | Namekey,
+    optional: boolean,
+    out: boolean,
+    ref: boolean,
+    refReadonly: boolean,
+    refkey: Refkey,
+    type: Children,
+  }).children(children)
+  ```
+
+## Props
+
+|             |                                                        |                                                                                                                                                                                                                                       |
+| ----------- | ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| attributes  | optional [AttributesProp](../../types/attributesprop/) | Define attributes to attach                                                                                                                                                                                                           |
+| default     | optional [Children](../../../core/types/children/)     | Default value for the parameter                                                                                                                                                                                                       |
+| in          | optional boolean                                       | Parameter modifier: The argument must be initialized before calling the method. The method can’t assign a new value to the parameter. The compiler might create a temporary variable to hold a copy of the argument to in parameters. |
+| name        | string \| [Namekey](../../../core/types/namekey/)      |                                                                                                                                                                                                                                       |
+| optional    | optional boolean                                       | If the parmaeter is optional(without default value)                                                                                                                                                                                   |
+| out         | optional boolean                                       | Parameter modifier: The calling method isn’t required to initialize the argument before calling the method. The method must assign a value to the parameter.                                                                          |
+| ref         | optional boolean                                       | Parameter modifier: The argument must be initialized before calling the method. The method can assign a new value to the parameter, but isn’t required to do so.                                                                      |
+| refReadonly | optional boolean                                       | Parameter modifier: The argument must be initialized before calling the method. The method can’t assign a new value to the parameter.                                                                                                 |
+| refkey      | optional [Refkey](../../../core/types/refkey/)         |                                                                                                                                                                                                                                       |
+| type        | [Children](../../../core/types/children/)              |                                                                                                                                                                                                                                       |

package/docs/api/components/Parameters_2.md

@@ -0,0 +1,27 @@
+# Parameters_2
+
+Render a collection of parameters
+
+* jsx
+
+  ```tsx
+  import { Parameters_2 } from "@alloy-js/csharp";
+
+
+  <Parameters_2 parameters={ParameterProps[] | undefined} />
+  ```
+
+* stc
+
+  ```ts
+  import { Parameters_2 } from "@alloy-js/csharp/stc";
+
+
+  Parameters_2({ parameters: ParameterProps[] | undefined }).children(children)
+  ```
+
+## Props
+
+|            |                                                 |   |
+| ---------- | ----------------------------------------------- | - |
+| parameters | [ParameterProps](../parameter/)\[] \| undefined |   |

package/docs/api/components/Property.md

@@ -0,0 +1,110 @@
+# Property
+
+Render a C# class property.
+
+Properties for [Property](../property/) component
+
+* jsx
+
+  ```tsx
+  import { Property } from "@alloy-js/csharp";
+
+
+  <Property
+    abstract
+    attributes={AttributesProp}
+    doc={Children}
+    extern
+    file
+    get={boolean | Children}
+    init
+    initializer={Children}
+    internal
+    name={Namekey | string}
+    new
+    nullable
+    override
+    private
+    protected
+    public
+    readonly
+    refkey={Refkey}
+    required
+    sealed
+    set={boolean | Children}
+    static
+    type={Children}
+    virtual
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { Property } from "@alloy-js/csharp/stc";
+
+
+  Property({
+    abstract: boolean,
+    attributes: AttributesProp,
+    doc: Children,
+    extern: boolean,
+    file: boolean,
+    get: boolean | Children,
+    init: boolean,
+    initializer: Children,
+    internal: boolean,
+    name: Namekey | string,
+    new: boolean,
+    nullable: boolean,
+    override: boolean,
+    private: boolean,
+    protected: boolean,
+    public: boolean,
+    readonly: boolean,
+    refkey: Refkey,
+    required: boolean,
+    sealed: boolean,
+    set: boolean | Children,
+    static: boolean,
+    type: Children,
+    virtual: boolean,
+  }).children(children)
+  ```
+
+## Props
+
+|             |                                                               |                                                                                                                                |
+| ----------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| abstract    | optional boolean                                              |                                                                                                                                |
+| attributes  | optional [AttributesProp](../../types/attributesprop/)        | Define attributes to attach                                                                                                    |
+| doc         | optional [Children](../../../core/types/children/)            | Doc comment                                                                                                                    |
+| extern      | optional boolean                                              |                                                                                                                                |
+| file        | optional boolean                                              |                                                                                                                                |
+| get         | optional boolean \| [Children](../../../core/types/children/) | If property should have a getter. Pass `true` for an auto-property getter (`get;`), or pass children for a getter with a body. |
+| init        | optional boolean                                              | If property should only be set on the type creation                                                                            |
+| initializer | optional [Children](../../../core/types/children/)            | Property initializer                                                                                                           |
+| internal    | optional boolean                                              |                                                                                                                                |
+| name        | [Namekey](../../../core/types/namekey/) \| string             |                                                                                                                                |
+| new         | optional boolean                                              |                                                                                                                                |
+| nullable    | optional boolean                                              | Property initializer                                                                                                           |
+| override    | optional boolean                                              |                                                                                                                                |
+| private     | optional boolean                                              |                                                                                                                                |
+| protected   | optional boolean                                              |                                                                                                                                |
+| public      | optional boolean                                              |                                                                                                                                |
+| readonly    | optional boolean                                              |                                                                                                                                |
+| refkey      | optional [Refkey](../../../core/types/refkey/)                |                                                                                                                                |
+| required    | optional boolean                                              | Set required modifier on property <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required>       |
+| sealed      | optional boolean                                              |                                                                                                                                |
+| set         | optional boolean \| [Children](../../../core/types/children/) | If property should have a setter. Pass `true` for an auto-property setter (`set;`), or pass children for a setter with a body. |
+| static      | optional boolean                                              |                                                                                                                                |
+| type        | [Children](../../../core/types/children/)                     | Property type                                                                                                                  |
+| virtual     | optional boolean                                              |                                                                                                                                |
+
+## Example
+
+`<ClassProperty public name="My" get set />`
+
+```cs
+public int My { get; set; };
+```