@alloy-js/go 0.3.0-dev.3 → 0.3.1-dev.0

package/docs/api/components/FunctionDeclaration.md

@@ -0,0 +1,53 @@
+# FunctionDeclaration
+
+* jsx
+
+  ```tsx
+  import { FunctionDeclaration } from "@alloy-js/go";
+
+
+  <FunctionDeclaration
+    doc={Children}
+    name={string | Namekey}
+    parameters={FunctionParameterProps[]}
+    receiver={Children}
+    refkey={Refkey}
+    returns={Children}
+    singleLine
+    typeParameters={TypeParameterProps[]}
+  >
+    {children}
+  </FunctionDeclaration>
+  ```
+
+* stc
+
+  ```ts
+  import { FunctionDeclaration } from "@alloy-js/go/stc";
+
+
+  FunctionDeclaration({
+    doc: Children,
+    name: string | Namekey,
+    parameters: FunctionParameterProps[],
+    receiver: Children,
+    refkey: Refkey,
+    returns: Children,
+    singleLine: boolean,
+    typeParameters: TypeParameterProps[],
+  }).children(children)
+  ```
+
+## Props
+
+|                |                                                             |                                                                                                                                                                |
+| -------------- | ----------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| children       | optional [Children](../../../core/types/children/)          |                                                                                                                                                                |
+| doc            | optional [Children](../../../core/types/children/)          | Doc comment                                                                                                                                                    |
+| name           | string \| [Namekey](../../../core/types/namekey/)           |                                                                                                                                                                |
+| parameters     | optional [FunctionParameterProps](../functionparameter/)\[] |                                                                                                                                                                |
+| receiver       | optional [Children](../../../core/types/children/)          | Go receiver (for methods)                                                                                                                                      |
+| refkey         | optional [Refkey](../../../core/types/refkey/)              |                                                                                                                                                                |
+| returns        | optional [Children](../../../core/types/children/)          |                                                                                                                                                                |
+| singleLine     | optional boolean                                            | Whether to render the function in a single line. This will only compile if `children` is a single line as well. This is not common in Go, so use with caution. |
+| typeParameters | optional [TypeParameterProps](../typeparameter/)\[]         | Type parameters for generic functions                                                                                                                          |

package/docs/api/components/FunctionParameter.md

@@ -0,0 +1,40 @@
+# FunctionParameter
+
+Define a parameter to be used in functions.
+
+* jsx
+
+  ```tsx
+  import { FunctionParameter } from "@alloy-js/go";
+
+
+  <FunctionParameter
+    name={string | Namekey}
+    refkey={Refkey}
+    type={Children}
+    variadic
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { FunctionParameter } from "@alloy-js/go/stc";
+
+
+  FunctionParameter({
+    name: string | Namekey,
+    refkey: Refkey,
+    type: Children,
+    variadic: boolean,
+  }).children(children)
+  ```
+
+## Props
+
+|          |                                                   |   |
+| -------- | ------------------------------------------------- | - |
+| name     | string \| [Namekey](../../../core/types/namekey/) |   |
+| refkey   | optional [Refkey](../../../core/types/refkey/)    |   |
+| type     | [Children](../../../core/types/children/)         |   |
+| variadic | optional boolean                                  |   |

package/docs/api/components/FunctionParameters.md

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

package/docs/api/components/FunctionReceiver.md

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

package/docs/api/components/ImportStatements.md

@@ -0,0 +1,25 @@
+# ImportStatements
+
+* jsx
+
+  ```tsx
+  import { ImportStatements } from "@alloy-js/go";
+
+
+  <ImportStatements records={ImportRecords} />
+  ```
+
+* stc
+
+  ```ts
+  import { ImportStatements } from "@alloy-js/go/stc";
+
+
+  ImportStatements({ records: ImportRecords }).children(children)
+  ```
+
+## Props
+
+|         |                                             |   |
+| ------- | ------------------------------------------- | - |
+| records | [ImportRecords](../../types/importrecords/) |   |

package/docs/api/components/InterfaceDeclaration.md

@@ -0,0 +1,54 @@
+# InterfaceDeclaration
+
+Go interface declaration.
+
+Properties for creating an interface declaration. This can be used for both named and anonymous interfaces. For named interfaces, use `InterfaceTypeDeclarationProps` instead.
+
+* jsx
+
+  ```tsx
+  import { InterfaceDeclaration } from "@alloy-js/go";
+
+
+  <InterfaceDeclaration refkey={Refkey} singleLine>
+    {children}
+  </InterfaceDeclaration>
+  ```
+
+* stc
+
+  ```ts
+  import { InterfaceDeclaration } from "@alloy-js/go/stc";
+
+
+  InterfaceDeclaration({
+    refkey: Refkey,
+    singleLine: boolean,
+  }).children(children)
+  ```
+
+## Props
+
+|            |                                                    |                                                                                                                                                                 |
+| ---------- | -------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| children   | optional [Children](../../../core/types/children/) |                                                                                                                                                                 |
+| refkey     | optional [Refkey](../../../core/types/refkey/)     |                                                                                                                                                                 |
+| singleLine | optional boolean                                   | Whether to render the interface in a single line. This will only compile if `children` is a single line as well. This is not common in Go, so use with caution. |
+
+## Example
+
+```tsx
+<InterfaceDeclaration>
+  <InterfaceEmbed>{MyOtherInterface}</InterfaceEmbed>
+  <InterfaceFunction name="MyFunc" parameters={params} returns="int" />
+</InterfaceDeclaration>
+```
+
+This will produce:
+
+```go
+interface {
+  MyOtherInterface
+  func MyFunc(param Param) int
+}
+```

package/docs/api/components/InterfaceEmbed.md

@@ -0,0 +1,29 @@
+# InterfaceEmbed
+
+* jsx
+
+  ```tsx
+  import { InterfaceEmbed } from "@alloy-js/go";
+
+
+  <InterfaceEmbed doc={Children} refkey={Refkey}>
+    {children}
+  </InterfaceEmbed>
+  ```
+
+* stc
+
+  ```ts
+  import { InterfaceEmbed } from "@alloy-js/go/stc";
+
+
+  InterfaceEmbed({ doc: Children, refkey: Refkey }).children(children)
+  ```
+
+## Props
+
+|          |                                                    |             |
+| -------- | -------------------------------------------------- | ----------- |
+| children | optional [Children](../../../core/types/children/) |             |
+| doc      | optional [Children](../../../core/types/children/) | Doc comment |
+| refkey   | optional [Refkey](../../../core/types/refkey/)     |             |

package/docs/api/components/InterfaceFunction.md

@@ -0,0 +1,41 @@
+# InterfaceFunction
+
+* jsx
+
+  ```tsx
+  import { InterfaceFunction } from "@alloy-js/go";
+
+
+  <InterfaceFunction
+    doc={Children}
+    name={string | Namekey}
+    parameters={FunctionParameterProps[]}
+    refkey={Refkey}
+    returns={Children}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { InterfaceFunction } from "@alloy-js/go/stc";
+
+
+  InterfaceFunction({
+    doc: Children,
+    name: string | Namekey,
+    parameters: FunctionParameterProps[],
+    refkey: Refkey,
+    returns: Children,
+  }).children(children)
+  ```
+
+## Props
+
+|            |                                                             |             |
+| ---------- | ----------------------------------------------------------- | ----------- |
+| doc        | optional [Children](../../../core/types/children/)          | Doc comment |
+| name       | string \| [Namekey](../../../core/types/namekey/)           |             |
+| parameters | optional [FunctionParameterProps](../functionparameter/)\[] |             |
+| refkey     | optional [Refkey](../../../core/types/refkey/)              |             |
+| returns    | optional [Children](../../../core/types/children/)          |             |

package/docs/api/components/InterfaceTypeDeclaration.md

@@ -0,0 +1,56 @@
+# InterfaceTypeDeclaration
+
+Wrapper for creating a named interface type declaration.
+
+Properties for creating a named interface type declaration. This is a combination of `InterfaceDeclarationProps` and `TypeDeclarationProps`.
+
+* jsx
+
+  ```tsx
+  import { InterfaceTypeDeclaration } from "@alloy-js/go";
+
+
+  <InterfaceTypeDeclaration
+    alias
+    doc={Children}
+    name={string | Namekey}
+    refkey={Refkey}
+    refkey={Refkey}
+    singleLine
+    symbol={NamedTypeSymbol}
+    typeParameters={TypeParameterProps[]}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { InterfaceTypeDeclaration } from "@alloy-js/go/stc";
+
+
+  InterfaceTypeDeclaration({
+    alias: boolean,
+    doc: Children,
+    name: string | Namekey,
+    refkey: Refkey,
+    refkey: Refkey,
+    singleLine: boolean,
+    symbol: NamedTypeSymbol,
+    typeParameters: TypeParameterProps[],
+  }).children(children)
+  ```
+
+## Props
+
+|                |                                                          |                                                                                                                                                                 |
+| -------------- | -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| alias          | optional boolean                                         | Whether the type is an alias                                                                                                                                    |
+| children       | optional [Children](../../../core/types/children/)       |                                                                                                                                                                 |
+| children       | optional [Children](../../../core/types/children/)       | Type expression                                                                                                                                                 |
+| doc            | optional [Children](../../../core/types/children/)       | Documentation comment                                                                                                                                           |
+| name           | string \| [Namekey](../../../core/types/namekey/)        | Type name                                                                                                                                                       |
+| refkey         | optional [Refkey](../../../core/types/refkey/)           |                                                                                                                                                                 |
+| refkey         | optional [Refkey](../../../core/types/refkey/)           | Type refkey                                                                                                                                                     |
+| singleLine     | optional boolean                                         | Whether to render the interface in a single line. This will only compile if `children` is a single line as well. This is not common in Go, so use with caution. |
+| symbol         | optional [NamedTypeSymbol](../../types/namedtypesymbol/) | Type symbol                                                                                                                                                     |
+| typeParameters | optional [TypeParameterProps](../typeparameter/)\[]      | Type parameters                                                                                                                                                 |

package/docs/api/components/LineComment.md

@@ -0,0 +1,29 @@
+# LineComment
+
+A Go line comment block. The children of this component are joined with two hard linebreaks. This is useful for creating line comments with multiple paragraphs.
+
+* jsx
+
+  ```tsx
+  import { LineComment } from "@alloy-js/go";
+
+
+  <LineComment >
+    {children}
+  </LineComment>
+  ```
+
+* stc
+
+  ```ts
+  import { LineComment } from "@alloy-js/go/stc";
+
+
+  LineComment({  }).children(children)
+  ```
+
+## Props
+
+|          |                                           |   |
+| -------- | ----------------------------------------- | - |
+| children | [Children](../../../core/types/children/) |   |

package/docs/api/components/ModuleDirectory.md

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

package/docs/api/components/Name.md

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

package/docs/api/components/Pointer.md

@@ -0,0 +1,29 @@
+# Pointer
+
+A Go pointer type that wraps the given type.
+
+* jsx
+
+  ```tsx
+  import { Pointer } from "@alloy-js/go";
+
+
+  <Pointer >
+    {children}
+  </Pointer>
+  ```
+
+* stc
+
+  ```ts
+  import { Pointer } from "@alloy-js/go/stc";
+
+
+  Pointer({  }).children(children)
+  ```
+
+## Props
+
+|          |                                           |   |
+| -------- | ----------------------------------------- | - |
+| children | [Children](../../../core/types/children/) |   |

package/docs/api/components/Reference.md

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

package/docs/api/components/SingleImportStatement.md

@@ -0,0 +1,35 @@
+# SingleImportStatement
+
+* jsx
+
+  ```tsx
+  import { SingleImportStatement } from "@alloy-js/go";
+
+
+  <SingleImportStatement blank dot local package={GoSymbol} path="string" />
+  ```
+
+* stc
+
+  ```ts
+  import { SingleImportStatement } from "@alloy-js/go/stc";
+
+
+  SingleImportStatement({
+    blank: boolean,
+    dot: boolean,
+    local: boolean,
+    package: GoSymbol,
+    path: string,
+  }).children(children)
+  ```
+
+## Props
+
+|         |                                            |   |
+| ------- | ------------------------------------------ | - |
+| blank   | optional boolean                           |   |
+| dot     | optional boolean                           |   |
+| local   | optional boolean                           |   |
+| package | optional [GoSymbol](../../types/gosymbol/) |   |
+| path    | string                                     |   |

package/docs/api/components/SourceDirectory.md

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

package/docs/api/components/SourceFile.md

@@ -0,0 +1,44 @@
+# SourceFile
+
+* jsx
+
+  ```tsx
+  import { SourceFile } from "@alloy-js/go";
+
+
+  <SourceFile
+    export={boolean | string}
+    header={Children}
+    headerComment="string"
+    package="string"
+    path="string"
+  >
+    {children}
+  </SourceFile>
+  ```
+
+* stc
+
+  ```ts
+  import { SourceFile } from "@alloy-js/go/stc";
+
+
+  SourceFile({
+    export: boolean | string,
+    header: Children,
+    headerComment: string,
+    package: string,
+    path: string,
+  }).children(children)
+  ```
+
+## Props
+
+|               |                                                    |   |
+| ------------- | -------------------------------------------------- | - |
+| children      | optional [Children](../../../core/types/children/) |   |
+| export        | optional boolean \| string                         |   |
+| header        | optional [Children](../../../core/types/children/) |   |
+| headerComment | optional string                                    |   |
+| package       | optional string                                    |   |
+| path          | string                                             |   |

package/docs/api/components/StructDeclaration.md

@@ -0,0 +1,51 @@
+# StructDeclaration
+
+Go struct declaration.
+
+Properties for creating a struct declaration. This can be used for both named and anonymous structs. For named structs, use `StructTypeDeclarationProps` instead.
+
+* jsx
+
+  ```tsx
+  import { StructDeclaration } from "@alloy-js/go";
+
+
+  <StructDeclaration refkey={Refkey} singleLine>
+    {children}
+  </StructDeclaration>
+  ```
+
+* stc
+
+  ```ts
+  import { StructDeclaration } from "@alloy-js/go/stc";
+
+
+  StructDeclaration({ refkey: Refkey, singleLine: boolean }).children(children)
+  ```
+
+## Props
+
+|            |                                                    |                                                                                                                                                              |
+| ---------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| children   | optional [Children](../../../core/types/children/) |                                                                                                                                                              |
+| refkey     | optional [Refkey](../../../core/types/refkey/)     |                                                                                                                                                              |
+| singleLine | optional boolean                                   | Whether to render the struct in a single line. This will only compile if `children` is a single line as well. This is not common in Go, so use with caution. |
+
+## Example
+
+```tsx
+<StructDeclaration>
+  <StructEmbed pointer>{MyOtherStruct}</StructEmbed>
+  <StructMember exported name="MyProperty" type="int" />
+</StructDeclaration>
+```
+
+This will produce:
+
+```go
+struct {
+  MyOtherStruct
+  MyProperty int
+}
+```