@alloy-js/go 0.3.0-dev.2 → 0.3.0

package/docs/api/components/StructEmbed.md

@@ -0,0 +1,29 @@
+# StructEmbed
+
+* jsx
+
+  ```tsx
+  import { StructEmbed } from "@alloy-js/go";
+
+
+  <StructEmbed doc={Children} refkey={Refkey}>
+    {children}
+  </StructEmbed>
+  ```
+
+* stc
+
+  ```ts
+  import { StructEmbed } from "@alloy-js/go/stc";
+
+
+  StructEmbed({ 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/StructMember.md

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

package/docs/api/components/StructTypeDeclaration.md

@@ -0,0 +1,56 @@
+# StructTypeDeclaration
+
+Wrapper for creating a named struct type declaration.
+
+Properties for creating a named struct type declaration. This is a combination of `StructDeclarationProps` and `TypeDeclarationProps`.
+
+* jsx
+
+  ```tsx
+  import { StructTypeDeclaration } from "@alloy-js/go";
+
+
+  <StructTypeDeclaration
+    alias
+    doc={Children}
+    name={string | Namekey}
+    refkey={Refkey}
+    refkey={Refkey}
+    singleLine
+    symbol={NamedTypeSymbol}
+    typeParameters={TypeParameterProps[]}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { StructTypeDeclaration } from "@alloy-js/go/stc";
+
+
+  StructTypeDeclaration({
+    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 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. |
+| symbol         | optional [NamedTypeSymbol](../../types/namedtypesymbol/) | Type symbol                                                                                                                                                  |
+| typeParameters | optional [TypeParameterProps](../typeparameter/)\[]      | Type parameters                                                                                                                                              |

package/docs/api/components/TypeConstraint.md

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

package/docs/api/components/TypeDeclaration.md

@@ -0,0 +1,47 @@
+# TypeDeclaration
+
+* jsx
+
+  ```tsx
+  import { TypeDeclaration } from "@alloy-js/go";
+
+
+  <TypeDeclaration
+    alias
+    doc={Children}
+    name={string | Namekey}
+    refkey={Refkey}
+    symbol={NamedTypeSymbol}
+    typeParameters={TypeParameterProps[]}
+  >
+    {children}
+  </TypeDeclaration>
+  ```
+
+* stc
+
+  ```ts
+  import { TypeDeclaration } from "@alloy-js/go/stc";
+
+
+  TypeDeclaration({
+    alias: boolean,
+    doc: Children,
+    name: string | Namekey,
+    refkey: Refkey,
+    symbol: NamedTypeSymbol,
+    typeParameters: TypeParameterProps[],
+  }).children(children)
+  ```
+
+## Props
+
+|                |                                                          |                              |
+| -------------- | -------------------------------------------------------- | ---------------------------- |
+| alias          | optional boolean                                         | Whether the type is an alias |
+| 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/)           | Type refkey                  |
+| symbol         | optional [NamedTypeSymbol](../../types/namedtypesymbol/) | Type symbol                  |
+| typeParameters | optional [TypeParameterProps](../typeparameter/)\[]      | Type parameters              |

package/docs/api/components/TypeDeclarationGroup.md

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

package/docs/api/components/TypeParameter.md

@@ -0,0 +1,37 @@
+# TypeParameter
+
+Information for a Go generic type parameter.
+
+* jsx
+
+  ```tsx
+  import { TypeParameter } from "@alloy-js/go";
+
+
+  <TypeParameter
+    constraint={Children}
+    name={string | Namekey}
+    refkey={Refkey}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { TypeParameter } from "@alloy-js/go/stc";
+
+
+  TypeParameter({
+    constraint: Children,
+    name: string | Namekey,
+    refkey: Refkey,
+  }).children(children)
+  ```
+
+## Props
+
+|            |                                                   |                                   |
+| ---------- | ------------------------------------------------- | --------------------------------- |
+| constraint | [Children](../../../core/types/children/)         | The parameter constraint          |
+| name       | string \| [Namekey](../../../core/types/namekey/) | The name of the type parameter.   |
+| refkey     | optional [Refkey](../../../core/types/refkey/)    | A refkey for this type parameter. |

package/docs/api/components/TypeParameters.md

@@ -0,0 +1,25 @@
+# TypeParameters
+
+* jsx
+
+  ```tsx
+  import { TypeParameters } from "@alloy-js/go";
+
+
+  <TypeParameters parameters={TypeParameterProps[]} />
+  ```
+
+* stc
+
+  ```ts
+  import { TypeParameters } from "@alloy-js/go/stc";
+
+
+  TypeParameters({ parameters: TypeParameterProps[] }).children(children)
+  ```
+
+## Props
+
+|            |                                                     |            |
+| ---------- | --------------------------------------------------- | ---------- |
+| parameters | optional [TypeParameterProps](../typeparameter/)\[] | Parameters |

package/docs/api/components/VariableDeclaration.md

@@ -0,0 +1,44 @@
+# VariableDeclaration
+
+* jsx
+
+  ```tsx
+  import { VariableDeclaration } from "@alloy-js/go";
+
+
+  <VariableDeclaration
+    const
+    doc={Children}
+    name={string | Namekey}
+    refkey={Refkey}
+    type={Children}
+  >
+    {children}
+  </VariableDeclaration>
+  ```
+
+* stc
+
+  ```ts
+  import { VariableDeclaration } from "@alloy-js/go/stc";
+
+
+  VariableDeclaration({
+    const: boolean,
+    doc: Children,
+    name: string | Namekey,
+    refkey: Refkey,
+    type: Children,
+  }).children(children)
+  ```
+
+## Props
+
+|          |                                                    |                                       |
+| -------- | -------------------------------------------------- | ------------------------------------- |
+| children | optional [Children](../../../core/types/children/) | Initializer expression                |
+| const    | optional boolean                                   | Whether this is a `const` declaration |
+| doc      | optional [Children](../../../core/types/children/) | Documentation comment                 |
+| 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      |

package/docs/api/components/VariableDeclarationGroup.md

@@ -0,0 +1,28 @@
+# VariableDeclarationGroup
+
+* jsx
+
+  ```tsx
+  import { VariableDeclarationGroup } from "@alloy-js/go";
+
+
+  <VariableDeclarationGroup const>
+    {children}
+  </VariableDeclarationGroup>
+  ```
+
+* stc
+
+  ```ts
+  import { VariableDeclarationGroup } from "@alloy-js/go/stc";
+
+
+  VariableDeclarationGroup({ const: boolean }).children(children)
+  ```
+
+## Props
+
+|          |                                           |   |
+| -------- | ----------------------------------------- | - |
+| children | [Children](../../../core/types/children/) |   |
+| const    | optional boolean                          |   |

package/docs/api/components/index.md

@@ -0,0 +1,30 @@
+# go — components
+
+- [FunctionDeclaration](FunctionDeclaration.md) — import { FunctionDeclaration } from "@alloy-js/go";
+- [FunctionParameter](FunctionParameter.md) — Define a parameter to be used in functions.
+- [FunctionParameters](FunctionParameters.md) — Render a collection of parameters
+- [FunctionReceiver](FunctionReceiver.md) — import { FunctionReceiver } from "@alloy-js/go";
+- [ImportStatements](ImportStatements.md) — import { ImportStatements } from "@alloy-js/go";
+- [InterfaceDeclaration](InterfaceDeclaration.md) — Go interface declaration.
+- [InterfaceEmbed](InterfaceEmbed.md) — import { InterfaceEmbed } from "@alloy-js/go";
+- [InterfaceFunction](InterfaceFunction.md) — import { InterfaceFunction } from "@alloy-js/go";
+- [InterfaceTypeDeclaration](InterfaceTypeDeclaration.md) — Wrapper for creating a named interface type declaration.
+- [LineComment](LineComment.md) — A Go line comment block.
+- [ModuleDirectory](ModuleDirectory.md) — import { ModuleDirectory } from "@alloy-js/go";
+- [Name](Name.md) — import { Name } from "@alloy-js/go";
+- [Pointer](Pointer.md) — A Go pointer type that wraps the given type.
+- [Reference](Reference.md) — import { Reference } from "@alloy-js/go";
+- [SingleImportStatement](SingleImportStatement.md) — import { SingleImportStatement } from "@alloy-js/go";
+- [SourceDirectory](SourceDirectory.md) — import { SourceDirectory } from "@alloy-js/go";
+- [SourceFile](SourceFile.md) — import { SourceFile } from "@alloy-js/go";
+- [StructDeclaration](StructDeclaration.md) — Go struct declaration.
+- [StructEmbed](StructEmbed.md) — import { StructEmbed } from "@alloy-js/go";
+- [StructMember](StructMember.md) — import { StructMember } from "@alloy-js/go";
+- [StructTypeDeclaration](StructTypeDeclaration.md) — Wrapper for creating a named struct type declaration.
+- [TypeConstraint](TypeConstraint.md) — import { TypeConstraint } from "@alloy-js/go";
+- [TypeDeclaration](TypeDeclaration.md) — import { TypeDeclaration } from "@alloy-js/go";
+- [TypeDeclarationGroup](TypeDeclarationGroup.md) — import { TypeDeclarationGroup } from "@alloy-js/go";
+- [TypeParameter](TypeParameter.md) — Information for a Go generic type parameter.
+- [TypeParameters](TypeParameters.md) — import { TypeParameters } from "@alloy-js/go";
+- [VariableDeclaration](VariableDeclaration.md) — import { VariableDeclaration } from "@alloy-js/go";
+- [VariableDeclarationGroup](VariableDeclarationGroup.md) — import { VariableDeclarationGroup } from "@alloy-js/go";

package/docs/api/contexts/TypeDeclarationGroup-context.md

@@ -0,0 +1,17 @@
+# TypeDeclarationGroup context
+
+```ts
+const TypeDeclarationGroupContext: ComponentContext<TypeDeclarationGroupContext>
+```
+
+## Accessor
+
+```ts
+const myContext = useContext(TypeDeclarationGroupContext);
+```
+
+## Context interface
+
+|        |         |   |
+| ------ | ------- | - |
+| active | boolean |   |

package/docs/api/contexts/VariableDeclarationGroup-context.md

@@ -0,0 +1,18 @@
+# VariableDeclarationGroup context
+
+```ts
+const VariableDeclarationGroupContext: ComponentContext<VariableDeclarationGroupContext>
+```
+
+## Accessor
+
+```ts
+const myContext = useContext(VariableDeclarationGroupContext);
+```
+
+## Context interface
+
+|        |         |   |
+| ------ | ------- | - |
+| active | boolean |   |
+| const  | boolean |   |

package/docs/api/contexts/index.md

@@ -0,0 +1,4 @@
+# go — contexts
+
+- [TypeDeclarationGroup context](TypeDeclarationGroup-context.md) — const TypeDeclarationGroupContext: ComponentContext<TypeDeclarationGroupContext>
+- [VariableDeclarationGroup context](VariableDeclarationGroup-context.md) — const VariableDeclarationGroupContext: ComponentContext<VariableDeclarationGroupContext>

package/docs/api/functions/createAnonymousTypeSymbol.md

@@ -0,0 +1,25 @@
+# createAnonymousTypeSymbol
+
+```ts
+import { createAnonymousTypeSymbol } from "@alloy-js/go";
+
+
+function createAnonymousTypeSymbol(kind: NamedTypeTypeKind, options?: NamedTypeSymbolOptions): NamedTypeSymbol;
+```
+
+## Parameters
+
+|         |                                 |   |
+| ------- | ------------------------------- | - |
+| kind    | NamedTypeTypeKind               |   |
+| options | optional NamedTypeSymbolOptions |   |
+
+## Options
+
+|                |                                               |   |
+| -------------- | --------------------------------------------- | - |
+| typeParameters | optional [GoSymbol](../../types/gosymbol/)\[] |   |
+
+## Returns
+
+[NamedTypeSymbol](../../types/namedtypesymbol/)

package/docs/api/functions/createFunctionScope.md

@@ -0,0 +1,26 @@
+# createFunctionScope
+
+```ts
+import { createFunctionScope } from "@alloy-js/go";
+
+
+function createFunctionScope(options?: OutputScopeOptions): GoFunctionScope;
+```
+
+## 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
+
+[GoFunctionScope](../../types/gofunctionscope/)

package/docs/api/functions/createFunctionSymbol.md

@@ -0,0 +1,35 @@
+# createFunctionSymbol
+
+```ts
+import { createFunctionSymbol } from "@alloy-js/go";
+
+
+function createFunctionSymbol(originalName: string | Namekey, isMethod: boolean, options?: GoSymbolOptions): FunctionSymbol;
+```
+
+## Parameters
+
+|              |                          |   |
+| ------------ | ------------------------ | - |
+| originalName | string \| Namekey        |   |
+| isMethod     | boolean                  |   |
+| options      | optional GoSymbolOptions |   |
+
+## 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
+
+[FunctionSymbol](../../types/functionsymbol/)

package/docs/api/functions/createGoModuleScope.md

@@ -0,0 +1,18 @@
+# createGoModuleScope
+
+```ts
+import { createGoModuleScope } from "@alloy-js/go";
+
+
+function createGoModuleScope(name: string): GoModuleScope;
+```
+
+## Parameters
+
+|      |        |   |
+| ---- | ------ | - |
+| name | string |   |
+
+## Returns
+
+[GoModuleScope](../../types/gomodulescope/)

package/docs/api/functions/createGoNamePolicy.md

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

package/docs/api/functions/createGoPackageScope.md

@@ -0,0 +1,18 @@
+# createGoPackageScope
+
+```ts
+import { createGoPackageScope } from "@alloy-js/go";
+
+
+function createGoPackageScope(packageSymbol: PackageSymbol): GoPackageScope;
+```
+
+## Parameters
+
+|               |               |   |
+| ------------- | ------------- | - |
+| packageSymbol | PackageSymbol |   |
+
+## Returns
+
+[GoPackageScope](../../types/gopackagescope/)

package/docs/api/functions/createInterfaceMemberSymbol.md

@@ -0,0 +1,25 @@
+# createInterfaceMemberSymbol
+
+```ts
+import { createInterfaceMemberSymbol } from "@alloy-js/go";
+
+
+function createInterfaceMemberSymbol(originalName: string | Namekey, options?: NamedTypeSymbolOptions): NamedTypeSymbol;
+```
+
+## Parameters
+
+|              |                                 |   |
+| ------------ | ------------------------------- | - |
+| originalName | string \| Namekey               |   |
+| options      | optional NamedTypeSymbolOptions |   |
+
+## Options
+
+|                |                                               |   |
+| -------------- | --------------------------------------------- | - |
+| typeParameters | optional [GoSymbol](../../types/gosymbol/)\[] |   |
+
+## Returns
+
+[NamedTypeSymbol](../../types/namedtypesymbol/)

package/docs/api/functions/createModule.md

@@ -0,0 +1,20 @@
+# createModule
+
+```ts
+import { createModule } from "@alloy-js/go";
+
+
+function createModule<T extends PackageDescriptor<any>>(name: string, props: T, builtin?: boolean): LibraryFrom<T>;
+```
+
+## Parameters
+
+|         |                  |   |
+| ------- | ---------------- | - |
+| name    | string           |   |
+| props   | T                |   |
+| builtin | optional boolean |   |
+
+## Returns
+
+[LibraryFrom](../../types/libraryfrom/)\<T>