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

package/docs/api/functions/createNamedTypeScope.md

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

package/docs/api/functions/createNestedStructSymbol.md

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

package/docs/api/functions/createPackageSymbol.md

@@ -0,0 +1,19 @@
+# createPackageSymbol
+
+```ts
+import { createPackageSymbol } from "@alloy-js/go";
+
+
+function createPackageSymbol(name: string, path?: string): PackageSymbol;
+```
+
+## Parameters
+
+|      |                 |   |
+| ---- | --------------- | - |
+| name | string          |   |
+| path | optional string |   |
+
+## Returns
+
+[PackageSymbol](../../types/packagesymbol/)

package/docs/api/functions/createParameterSymbol.md

@@ -0,0 +1,36 @@
+# createParameterSymbol
+
+Create a symbol for a parameter in the current func scope.
+
+```ts
+import { createParameterSymbol } from "@alloy-js/go";
+
+
+function createParameterSymbol(originalName: string | Namekey, options?: GoSymbolOptions): GoSymbol;
+```
+
+## Parameters
+
+|              |                          |   |
+| ------------ | ------------------------ | - |
+| originalName | string \| Namekey        |   |
+| 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
+
+[GoSymbol](../../types/gosymbol/)

package/docs/api/functions/createPropertySymbol.md

@@ -0,0 +1,34 @@
+# createPropertySymbol
+
+```ts
+import { createPropertySymbol } from "@alloy-js/go";
+
+
+function createPropertySymbol(originalName: string | Namekey, options: GoSymbolOptions): GoSymbol;
+```
+
+## Parameters
+
+|              |                   |   |
+| ------------ | ----------------- | - |
+| originalName | string \| Namekey |   |
+| options      | 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
+
+[GoSymbol](../../types/gosymbol/)

package/docs/api/functions/createStructMemberSymbol.md

@@ -0,0 +1,25 @@
+# createStructMemberSymbol
+
+```ts
+import { createStructMemberSymbol } from "@alloy-js/go";
+
+
+function createStructMemberSymbol(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/createTypeParameterSymbol.md

@@ -0,0 +1,25 @@
+# createTypeParameterSymbol
+
+```ts
+import { createTypeParameterSymbol } from "@alloy-js/go";
+
+
+function createTypeParameterSymbol(originalName: string | Namekey, options?: CreateTypeParameterSymbolOptions): GoSymbol;
+```
+
+## Parameters
+
+|              |                                           |   |
+| ------------ | ----------------------------------------- | - |
+| originalName | string \| Namekey                         |   |
+| options      | optional CreateTypeParameterSymbolOptions |   |
+
+## Options
+
+|       |                                                                                                               |   |
+| ----- | ------------------------------------------------------------------------------------------------------------- | - |
+| scope | optional [GoFunctionScope](../../types/gofunctionscope/) \| [GoNamedTypeScope](../../types/gonamedtypescope/) |   |
+
+## Returns
+
+[GoSymbol](../../types/gosymbol/)

package/docs/api/functions/createTypeSymbol.md

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

package/docs/api/functions/createVariableSymbol.md

@@ -0,0 +1,34 @@
+# createVariableSymbol
+
+```ts
+import { createVariableSymbol } from "@alloy-js/go";
+
+
+function createVariableSymbol(originalName: string | Namekey, options?: GoSymbolOptions): GoSymbol;
+```
+
+## Parameters
+
+|              |                          |   |
+| ------------ | ------------------------ | - |
+| originalName | string \| Namekey        |   |
+| 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
+
+[GoSymbol](../../types/gosymbol/)

package/docs/api/functions/index.md

@@ -0,0 +1,29 @@
+# go — functions
+
+- [createAnonymousTypeSymbol](createAnonymousTypeSymbol.md) — import { createAnonymousTypeSymbol } from "@alloy-js/go";
+- [createFunctionScope](createFunctionScope.md) — import { createFunctionScope } from "@alloy-js/go";
+- [createFunctionSymbol](createFunctionSymbol.md) — import { createFunctionSymbol } from "@alloy-js/go";
+- [createGoModuleScope](createGoModuleScope.md) — import { createGoModuleScope } from "@alloy-js/go";
+- [createGoNamePolicy](createGoNamePolicy.md) — import { createGoNamePolicy } from "@alloy-js/go";
+- [createGoPackageScope](createGoPackageScope.md) — import { createGoPackageScope } from "@alloy-js/go";
+- [createInterfaceMemberSymbol](createInterfaceMemberSymbol.md) — import { createInterfaceMemberSymbol } from "@alloy-js/go";
+- [createModule](createModule.md) — import { createModule } from "@alloy-js/go";
+- [createNamedTypeScope](createNamedTypeScope.md) — import { createNamedTypeScope } from "@alloy-js/go";
+- [createNestedStructSymbol](createNestedStructSymbol.md) — import { createNestedStructSymbol } from "@alloy-js/go";
+- [createPackageSymbol](createPackageSymbol.md) — import { createPackageSymbol } from "@alloy-js/go";
+- [createParameterSymbol](createParameterSymbol.md) — Create a symbol for a parameter in the current func scope.
+- [createPropertySymbol](createPropertySymbol.md) — import { createPropertySymbol } from "@alloy-js/go";
+- [createStructMemberSymbol](createStructMemberSymbol.md) — import { createStructMemberSymbol } from "@alloy-js/go";
+- [createTypeParameterSymbol](createTypeParameterSymbol.md) — import { createTypeParameterSymbol } from "@alloy-js/go";
+- [createTypeSymbol](createTypeSymbol.md) — import { createTypeSymbol } from "@alloy-js/go";
+- [createVariableSymbol](createVariableSymbol.md) — import { createVariableSymbol } from "@alloy-js/go";
+- [ref](ref.md) — import { ref } from "@alloy-js/go";
+- [useEnclosingPackageScope](useEnclosingPackageScope.md) — import { useEnclosingPackageScope } from "@alloy-js/go";
+- [useFuncScope](useFuncScope.md) — import { useFuncScope } from "@alloy-js/go";
+- [useGoNamePolicy](useGoNamePolicy.md) — import { useGoNamePolicy } from "@alloy-js/go";
+- [useGoScope](useGoScope.md) — import { useGoScope } from "@alloy-js/go";
+- [useLexicalScope](useLexicalScope.md) — import { useLexicalScope } from "@alloy-js/go";
+- [useModule](useModule.md) — import { useModule } from "@alloy-js/go";
+- [useNamedTypeScope](useNamedTypeScope.md) — import { useNamedTypeScope } from "@alloy-js/go";
+- [usePackage](usePackage.md) — import { usePackage } from "@alloy-js/go";
+- [useSourceFileScope](useSourceFileScope.md) — import { useSourceFileScope } from "@alloy-js/go";

package/docs/api/functions/ref.md

@@ -0,0 +1,18 @@
+# ref
+
+```ts
+import { ref } from "@alloy-js/go";
+
+
+function ref(refkey: Refkey): () => [string, OutputSymbol | undefined];
+```
+
+## Parameters
+
+|        |        |   |
+| ------ | ------ | - |
+| refkey | Refkey |   |
+
+## Returns
+
+() => \[string, [OutputSymbol](../../../core/types/outputsymbol/) | undefined]

package/docs/api/functions/useEnclosingPackageScope.md

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

package/docs/api/functions/useFuncScope.md

@@ -0,0 +1,17 @@
+# useFuncScope
+
+```ts
+import { useFuncScope } from "@alloy-js/go";
+
+
+function useFuncScope(): GoFunctionScope;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+[GoFunctionScope](../../types/gofunctionscope/)

package/docs/api/functions/useGoNamePolicy.md

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

package/docs/api/functions/useGoScope.md

@@ -0,0 +1,17 @@
+# useGoScope
+
+```ts
+import { useGoScope } from "@alloy-js/go";
+
+
+function useGoScope(): GoScope;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+[GoScope](../../types/goscope/)

package/docs/api/functions/useLexicalScope.md

@@ -0,0 +1,17 @@
+# useLexicalScope
+
+```ts
+import { useLexicalScope } from "@alloy-js/go";
+
+
+function useLexicalScope(): GoLexicalScope;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+[GoLexicalScope](../../types/golexicalscope/)

package/docs/api/functions/useModule.md

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

package/docs/api/functions/useNamedTypeScope.md

@@ -0,0 +1,17 @@
+# useNamedTypeScope
+
+```ts
+import { useNamedTypeScope } from "@alloy-js/go";
+
+
+function useNamedTypeScope(): GoNamedTypeScope;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+[GoNamedTypeScope](../../types/gonamedtypescope/)

package/docs/api/functions/usePackage.md

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

package/docs/api/functions/useSourceFileScope.md

@@ -0,0 +1,17 @@
+# useSourceFileScope
+
+```ts
+import { useSourceFileScope } from "@alloy-js/go";
+
+
+function useSourceFileScope(): GoSourceFileScope | undefined;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+[GoSourceFileScope](../../types/gosourcefilescope/) | undefined

package/docs/api/index.md

@@ -0,0 +1,7 @@
+# @alloy-js/go API Reference
+
+- [components](components/index.md) (28 items)
+- [contexts](contexts/index.md) (2 items)
+- [functions](functions/index.md) (27 items)
+- [types](types/index.md) (36 items)
+- [variables](variables/index.md) (1 items)

package/docs/api/types/CreateTypeParameterSymbolOptions.md

@@ -0,0 +1,9 @@
+# CreateTypeParameterSymbolOptions
+
+## Members
+
+Extends [GoSymbolOptions](../gosymboloptions/)
+
+|       |                                                                                             |   |
+| ----- | ------------------------------------------------------------------------------------------- | - |
+| scope | optional [GoFunctionScope](../gofunctionscope/) \| [GoNamedTypeScope](../gonamedtypescope/) |   |

package/docs/api/types/Descriptor.md

@@ -0,0 +1,5 @@
+# Descriptor
+
+```ts
+type Descriptor = PackageDescriptor<any> | FieldDescriptor | FunctionDescriptor | MethodDescriptor | VariableDescriptor | StructDescriptor<any> | InterfaceDescriptor<any> | TypeDescriptor<any> | EmbedDescriptor;
+```

package/docs/api/types/EmbedDescriptor.md

@@ -0,0 +1,9 @@
+# EmbedDescriptor
+
+## Members
+
+Extends [MemberDescriptor](../memberdescriptor/)
+
+|      |         |   |
+| ---- | ------- | - |
+| kind | ”embed” |   |

package/docs/api/types/FieldDescriptor.md

@@ -0,0 +1,9 @@
+# FieldDescriptor
+
+## Members
+
+Extends [MemberDescriptor](../memberdescriptor/)
+
+|      |         |   |
+| ---- | ------- | - |
+| kind | ”field” |   |

package/docs/api/types/FunctionDescriptor.md

@@ -0,0 +1,9 @@
+# FunctionDescriptor
+
+## Members
+
+Extends [MemberDescriptor](../memberdescriptor/)
+
+|      |            |   |
+| ---- | ---------- | - |
+| kind | ”function” |   |

package/docs/api/types/FunctionSymbol.md

@@ -0,0 +1,13 @@
+# FunctionSymbol
+
+A symbol for a function in Go, including receivers.
+
+## Members
+
+Extends [GoSymbol](../gosymbol/)
+
+|                |                                                                                       |                                                         |
+| -------------- | ------------------------------------------------------------------------------------- | ------------------------------------------------------- |
+| constructor    | (name: string \| Namekey, spaces: OutputSpace \| undefined, options: GoSymbolOptions) | Constructs a new instance of the [`FunctionSymbol`](FunctionSymbol.md) class |
+| receiverSymbol | [NamedTypeSymbol](../namedtypesymbol/) \| undefined                                   |                                                         |
+| symbolKind     |                                                                                       |                                                         |

package/docs/api/types/GoElements.md

@@ -0,0 +1,5 @@
+# GoElements
+
+```ts
+type GoElements = "parameter" | "type-parameter" | "function" | "type" | "variable" | "struct-member" | "interface-member";
+```

package/docs/api/types/GoFunctionScope.md

@@ -0,0 +1,12 @@
+# GoFunctionScope
+
+## Members
+
+Extends [GoLexicalScope](../golexicalscope/)
+
+|                   |                                                 |   |
+| ----------------- | ----------------------------------------------- | - |
+| declarationSpaces | string\[]                                       |   |
+| localVariables    | [OutputSpace](../../../core/types/outputspace/) |   |
+| parameters        | [OutputSpace](../../../core/types/outputspace/) |   |
+| typeParameters    | [OutputSpace](../../../core/types/outputspace/) |   |

package/docs/api/types/GoLexicalScope.md

@@ -0,0 +1,11 @@
+# GoLexicalScope
+
+## Members
+
+Extends [GoScope](../goscope/)
+
+|                   |                                                 |   |
+| ----------------- | ----------------------------------------------- | - |
+| declarationSpaces | string\[]                                       |   |
+| types             | [OutputSpace](../../../core/types/outputspace/) |   |
+| values            | [OutputSpace](../../../core/types/outputspace/) |   |

package/docs/api/types/GoModuleScope.md

@@ -0,0 +1,10 @@
+# GoModuleScope
+
+## Members
+
+Extends [GoScope](../goscope/)
+
+|             |                                  |                                                        |
+| ----------- | -------------------------------- | ------------------------------------------------------ |
+| constructor | (name: string, builtin: boolean) | Constructs a new instance of the [`GoModuleScope`](GoModuleScope.md) class |
+| builtin     | boolean                          |                                                        |