@alloy-js/python 0.4.0-dev.5 → 0.4.0-dev.6

package/docs/api/components/VariableDeclaration.md

@@ -0,0 +1,87 @@
+# VariableDeclaration
+
+A variable declaration component for Python.
+
+* jsx
+
+  ```tsx
+  import { VariableDeclaration } from "@alloy-js/python";
+
+
+  <VariableDeclaration
+    callStatementVar
+    doc={Children}
+    initializer={Children}
+    instanceVariable
+    name={string | Namekey}
+    omitNone
+    refkey={Refkey | Refkey[]}
+    type={Children}
+   />
+  ```
+
+* stc
+
+  ```ts
+  import { VariableDeclaration } from "@alloy-js/python/stc";
+
+
+  VariableDeclaration({
+    callStatementVar: boolean,
+    doc: Children,
+    initializer: Children,
+    instanceVariable: boolean,
+    name: string | Namekey,
+    omitNone: boolean,
+    refkey: Refkey | Refkey[],
+    type: Children,
+  }).children(children)
+  ```
+
+## Props
+
+|                  |                                                                                            |                                                                                                                                            |
+| ---------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| callStatementVar | optional boolean                                                                           | Indicates if this is a call statement variable. Optional. This is used to handle cases where the variable is part of a call statement.     |
+| children         | optional [Children](../../../core/types/children/)                                         |                                                                                                                                            |
+| doc              | optional [Children](../../../core/types/children/)                                         | Documentation for this declaration                                                                                                         |
+| initializer      | optional [Children](../../../core/types/children/)                                         | The initial value of the variable.                                                                                                         |
+| instanceVariable | optional boolean                                                                           | Indicates if this variable is an instance variable. Optional. This is used to handle cases where the variable is part of a class instance. |
+| name             | string \| [Namekey](../../../core/types/namekey/)                                          | The base name of this declaration. May change depending on naming policy and any conflicts.                                                |
+| omitNone         | optional boolean                                                                           | Indicates if we should omit the None assignment. Optional.                                                                                 |
+| refkey           | optional [Refkey](../../../core/types/refkey/) \| [Refkey](../../../core/types/refkey/)\[] | The refkey or array of refkeys for this declaration.                                                                                       |
+| type             | optional [Children](../../../core/types/children/)                                         | The type of the variable. Used only for type annotation. Optional.                                                                         |
+
+## Example
+
+```tsx
+<VariableDeclaration
+  name="myVar"
+  type="int"
+  initializer={42}  // Initial value
+/>
+<VariableDeclaration
+  name="myOtherVar"
+  type="str"
+  omitNone={true}
+/>
+<VariableDeclaration
+  name="myCallStmtVar"
+  callStatementVar={true}
+  initializer={12}
+/>
+VariableDeclaration
+  name=""
+  callStatementVar={true}
+  initializer={12}
+/>
+```
+
+renders to
+
+```py
+myVar: int = 42
+myOtherVar: str
+myCallStmtVar=12
+12
+```

package/docs/api/components/index.md

@@ -0,0 +1,46 @@
+# python — components
+
+- [AttributeDoc](AttributeDoc.md) — A component that creates documentation for a single attribute.
+- [CallSignature](CallSignature.md) — A Python call signature, e.g.
+- [CallSignatureParameters](CallSignatureParameters.md) — A call signature parameters declaration, which can be used to define the parameters of a function or other callables.
+- [ClassDeclaration](ClassDeclaration.md) — Create a Python class declaration.
+- [ClassDoc](ClassDoc.md) — A component that creates a ClassDoc block for classes.
+- [ClassEnumDeclaration](ClassEnumDeclaration.md) — Create a Python enum using the class-based syntax.
+- [ClassInstantiation](ClassInstantiation.md) — Used to create new instances of classes in Python.
+- [ClassMethodDeclaration](ClassMethodDeclaration.md) — A Python class method declaration component.
+- [ConstructorDeclaration](ConstructorDeclaration.md) — A Python constructor declaration for `__new__`.
+- [DataclassDeclaration](DataclassDeclaration.md) — Renders a Python dataclass.
+- [Declaration](Declaration.md) — A Python declaration, which can be a class, function, variable, etc.
+- [DunderMethodDeclaration](DunderMethodDeclaration.md) — A Python dunder method declaration.
+- [EnumMember](EnumMember.md) — A Python enum member.
+- [ExceptionDoc](ExceptionDoc.md) — A component that creates an ExceptionDoc block for custom exception classes.
+- [FunctionalEnumDeclaration](FunctionalEnumDeclaration.md) — Create a Python enum using the functional syntax.
+- [FunctionCallExpression](FunctionCallExpression.md) — A Python function call expression.
+- [FunctionDeclaration](FunctionDeclaration.md) — A Python function declaration.
+- [FunctionDoc](FunctionDoc.md) — A component that creates a FunctionDoc block for functions.
+- [FutureStatement](FutureStatement.md) — A future statement that imports features from **future**.
+- [GeneratorDoc](GeneratorDoc.md) — A component that creates a GeneratorDoc block for generator functions.
+- [InlineDoc](InlineDoc.md) — An inline documentation component for attribute docstrings.
+- [LexicalScope](LexicalScope.md) — import { LexicalScope } from "@alloy-js/python";
+- [MemberExpression](MemberExpression.md) — Create a member expression from parts.
+- [MemberScope](MemberScope.md) — import { MemberScope } from "@alloy-js/python";
+- [MethodDeclaration](MethodDeclaration.md) — A Python instance method declaration component.
+- [MethodDoc](MethodDoc.md) — A component that creates a MethodDoc block for class methods.
+- [ModuleDoc](ModuleDoc.md) — A component that creates a ModuleDoc block for module-level documentation.
+- [PropertyDeclaration](PropertyDeclaration.md) — Declares a Python property with optional getter, setter, and deleter methods.
+- [PropertyDoc](PropertyDoc.md) — A component that creates a PropertyDoc block for `@property` decorated methods.
+- [PyDoc](PyDoc.md) — A PyDoc comment.
+- [PyDocExample](PyDocExample.md) — Create a PyDoc example, which is prepended by >>.
+- [PythonBlock](PythonBlock.md) — A Python block component that can be used to render a block of Python code.
+- [Reference](Reference.md) — A Python reference to a symbol, such as a variable, function, or class.
+- [SimpleCommentBlock](SimpleCommentBlock.md) — import { SimpleCommentBlock } from "@alloy-js/python";
+- [SimpleInlineComment](SimpleInlineComment.md) — import { SimpleInlineComment } from "@alloy-js/python";
+- [SourceFile](SourceFile.md) — A Python source file component that represents a Python file in the source directory.
+- [StatementList](StatementList.md) — A Python statement list, which is a list of statements that can be rendered in a Python source file.
+- [StaticMethodDeclaration](StaticMethodDeclaration.md) — A Python static method declaration component.
+- [TypeArguments](TypeArguments.md) — Render Python-style type arguments, e.g.
+- [TypeRefContext](TypeRefContext.md) — Set the current context of reference to be type reference.
+- [TypeReference](TypeReference.md) — A type reference like Foo\[T, P] or int.
+- [UnionTypeExpression](UnionTypeExpression.md) — import { UnionTypeExpression } from "@alloy-js/python";
+- [useSourceFile](useSourceFile.md) — import { useSourceFile } from "@alloy-js/python";
+- [VariableDeclaration](VariableDeclaration.md) — A variable declaration component for Python.

package/docs/api/components/useSourceFile.md

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

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

@@ -0,0 +1,18 @@
+# PythonSourceFile context
+
+```ts
+const PythonSourceFileContext: ComponentContext<PythonSourceFileContext>
+```
+
+## Accessor
+
+```ts
+const myContext = useContext(PythonSourceFileContext);
+```
+
+## Context interface
+
+|        |                                                     |                                                        |
+| ------ | --------------------------------------------------- | ------------------------------------------------------ |
+| module | string                                              | The module name for this file, e.g. ‘test’ for test.py |
+| scope  | [PythonModuleScope](../../types/pythonmodulescope/) |                                                        |

package/docs/api/contexts/index.md

@@ -0,0 +1,3 @@
+# python — contexts
+
+- [PythonSourceFile context](PythonSourceFile-context.md) — const PythonSourceFileContext: ComponentContext<PythonSourceFileContext>

package/docs/api/functions/createFunctionSymbol.md

@@ -0,0 +1,23 @@
+# createFunctionSymbol
+
+Creates a function symbol in the current scope.
+
+```ts
+import { createFunctionSymbol } from "@alloy-js/python";
+
+
+function createFunctionSymbol(name: string | Namekey, options?: {
+    refkeys?: any;
+}): PythonOutputSymbol;
+```
+
+## Parameters
+
+|         |                             |   |
+| ------- | --------------------------- | - |
+| name    | string \| Namekey           |   |
+| options | optional { refkeys?: any; } |   |
+
+## Returns
+
+[PythonOutputSymbol](../../types/pythonoutputsymbol/)

package/docs/api/functions/createMethodSymbol.md

@@ -0,0 +1,23 @@
+# createMethodSymbol
+
+Creates a method symbol in a class. Validates that the current scope is a member scope.
+
+```ts
+import { createMethodSymbol } from "@alloy-js/python";
+
+
+function createMethodSymbol(name: string | Namekey, options?: {
+    refkeys?: any;
+}): PythonOutputSymbol;
+```
+
+## Parameters
+
+|         |                             |   |
+| ------- | --------------------------- | - |
+| name    | string \| Namekey           |   |
+| options | optional { refkeys?: any; } |   |
+
+## Returns
+
+[PythonOutputSymbol](../../types/pythonoutputsymbol/)

package/docs/api/functions/createModule.md

@@ -0,0 +1,18 @@
+# createModule
+
+```ts
+import { createModule } from "@alloy-js/python";
+
+
+function createModule<const T extends ModuleDescriptor>(props: CreateModuleProps<T>): ModuleRefkeys<T> & SymbolCreator;
+```
+
+## Parameters
+
+|       |                       |   |
+| ----- | --------------------- | - |
+| props | CreateModuleProps\<T> |   |
+
+## Returns
+
+[ModuleRefkeys](../../types/modulerefkeys/)\<T> & [SymbolCreator](../../../core/types/symbolcreator/)

package/docs/api/functions/createPythonNamePolicy.md

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

package/docs/api/functions/getCallSignatureProps.md

@@ -0,0 +1,21 @@
+# getCallSignatureProps
+
+Extract only the call signature props from a props object which extends `CallSignatureProps`. You can provide default values for the props.
+
+```ts
+import { getCallSignatureProps } from "@alloy-js/python";
+
+
+function getCallSignatureProps(props: CallSignatureProps, defaults?: Partial<CallSignatureProps>): CallSignatureProps;
+```
+
+## Parameters
+
+|          |                                       |   |
+| -------- | ------------------------------------- | - |
+| props    | CallSignatureProps                    |   |
+| defaults | optional Partial\<CallSignatureProps> |   |
+
+## Returns
+
+[CallSignatureProps](../../components/callsignature/)

package/docs/api/functions/index.md

@@ -0,0 +1,13 @@
+# python — functions
+
+- [createFunctionSymbol](createFunctionSymbol.md) — Creates a function symbol in the current scope.
+- [createMethodSymbol](createMethodSymbol.md) — Creates a method symbol in a class.
+- [createModule](createModule.md) — import { createModule } from "@alloy-js/python";
+- [createPythonNamePolicy](createPythonNamePolicy.md) — import { createPythonNamePolicy } from "@alloy-js/python";
+- [getCallSignatureProps](getCallSignatureProps.md) — Extract only the call signature props from a props object which extends `CallSignatureProps`.
+- [isParameterDescriptor](isParameterDescriptor.md) — import { isParameterDescriptor } from "@alloy-js/python";
+- [isTypeRefContext](isTypeRefContext.md) — import { isTypeRefContext } from "@alloy-js/python";
+- [ref](ref.md) — import { ref } from "@alloy-js/python";
+- [usePythonLexicalScope](usePythonLexicalScope.md) — import { usePythonLexicalScope } from "@alloy-js/python";
+- [usePythonNamePolicy](usePythonNamePolicy.md) — import { usePythonNamePolicy } from "@alloy-js/python";
+- [usePythonScope](usePythonScope.md) — import { usePythonScope } from "@alloy-js/python";

package/docs/api/functions/isParameterDescriptor.md

@@ -0,0 +1,18 @@
+# isParameterDescriptor
+
+```ts
+import { isParameterDescriptor } from "@alloy-js/python";
+
+
+function isParameterDescriptor(param: unknown): param is ParameterDescriptor;
+```
+
+## Parameters
+
+|       |         |   |
+| ----- | ------- | - |
+| param | unknown |   |
+
+## Returns
+
+param is [ParameterDescriptor](../../types/parameterdescriptor/)

package/docs/api/functions/isTypeRefContext.md

@@ -0,0 +1,17 @@
+# isTypeRefContext
+
+```ts
+import { isTypeRefContext } from "@alloy-js/python";
+
+
+function isTypeRefContext(): boolean;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+boolean ‘true’ if in a type context, ‘false’ if in a value context.

package/docs/api/functions/ref.md

@@ -0,0 +1,25 @@
+# ref
+
+```ts
+import { ref } from "@alloy-js/python";
+
+
+function ref(refkey: Refkey, options?: RefOptions): () => [Children, PythonOutputSymbol | undefined];
+```
+
+## Parameters
+
+|         |                     |   |
+| ------- | ------------------- | - |
+| refkey  | Refkey              |   |
+| options | optional RefOptions |   |
+
+## Options
+
+|      |                  |                                                                                                                         |
+| ---- | ---------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| type | optional boolean | If true, this reference is only used in a type annotation context. The import will be guarded with `if TYPE_CHECKING:`. |
+
+## Returns
+
+() => \[[Children](../../../core/types/children/), [PythonOutputSymbol](../../types/pythonoutputsymbol/) | undefined]

package/docs/api/functions/usePythonLexicalScope.md

@@ -0,0 +1,17 @@
+# usePythonLexicalScope
+
+```ts
+import { usePythonLexicalScope } from "@alloy-js/python";
+
+
+function usePythonLexicalScope(): PythonLexicalScope | PythonModuleScope;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+[PythonLexicalScope](../../types/pythonlexicalscope/) | [PythonModuleScope](../../types/pythonmodulescope/)

package/docs/api/functions/usePythonNamePolicy.md

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

package/docs/api/functions/usePythonScope.md

@@ -0,0 +1,17 @@
+# usePythonScope
+
+```ts
+import { usePythonScope } from "@alloy-js/python";
+
+
+function usePythonScope(): PythonOutputScope;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+[PythonOutputScope](../../types/pythonoutputscope/)

package/docs/api/index.md

@@ -0,0 +1,7 @@
+# @alloy-js/python API Reference
+
+- [components](components/index.md) (44 items)
+- [contexts](contexts/index.md) (1 items)
+- [functions](functions/index.md) (11 items)
+- [types](types/index.md) (29 items)
+- [variables](variables/index.md) (6 items)

package/docs/api/types/AddImportOptions.md

@@ -0,0 +1,7 @@
+# AddImportOptions
+
+## Members
+
+|      |                  |                                                                                                                       |
+| ---- | ---------------- | --------------------------------------------------------------------------------------------------------------------- |
+| type | optional boolean | If true, this import is only used in type annotation contexts. Such imports will be guarded with `if TYPE_CHECKING:`. |

package/docs/api/types/BaseDeclarationProps.md

@@ -0,0 +1,10 @@
+# BaseDeclarationProps
+
+## Members
+
+|          |                                                                                            |                                                                                             |
+| -------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------- |
+| children | optional [Children](../../../core/types/children/)                                         |                                                                                             |
+| doc      | optional [Children](../../../core/types/children/)                                         | Documentation for this declaration                                                          |
+| name     | string \| [Namekey](../../../core/types/namekey/)                                          | The base name of this declaration. May change depending on naming policy and any conflicts. |
+| refkey   | optional [Refkey](../../../core/types/refkey/) \| [Refkey](../../../core/types/refkey/)\[] | The refkey or array of refkeys for this declaration.                                        |

package/docs/api/types/CommonFunctionProps.md

@@ -0,0 +1,15 @@
+# CommonFunctionProps
+
+Shared base interface for function-like components.
+
+## Members
+
+Extends [BaseDeclarationProps](../basedeclarationprops/),[CallSignatureProps](../../components/callsignature/)
+
+|       |                  |                                       |
+| ----- | ---------------- | ------------------------------------- |
+| async | optional boolean | Indicates that the function is async. |
+
+## Remarks
+
+This interface is consumed by public components like [`FunctionDeclaration`](../components/FunctionDeclaration.md), [`MethodDeclaration`](../components/MethodDeclaration.md), and property method helpers. It combines declaration metadata with call signature shape.

package/docs/api/types/CreateModuleProps.md

@@ -0,0 +1,8 @@
+# CreateModuleProps
+
+## Members
+
+|            |        |   |
+| ---------- | ------ | - |
+| descriptor | T      |   |
+| name       | string |   |

package/docs/api/types/CreatePythonSymbolFunctionOptions.md

@@ -0,0 +1,9 @@
+# CreatePythonSymbolFunctionOptions
+
+## Members
+
+Extends [PythonOutputSymbolOptions](../pythonoutputsymboloptions/)
+
+|      |        |   |
+| ---- | ------ | - |
+| name | string |   |

package/docs/api/types/DataclassDecoratorKey.md

@@ -0,0 +1,5 @@
+# DataclassDecoratorKey
+
+```ts
+type DataclassDecoratorKey = (typeof dataclassDecoratorKeys)[number];
+```

package/docs/api/types/DataclassDecoratorKwargs.md

@@ -0,0 +1,5 @@
+# DataclassDecoratorKwargs
+
+```ts
+type DataclassDecoratorKwargs = Partial<Record<DataclassDecoratorKey, boolean>>;
+```

package/docs/api/types/EnumPropsBase.md

@@ -0,0 +1,11 @@
+# EnumPropsBase
+
+## Members
+
+Extends [BaseDeclarationProps](../basedeclarationprops/)
+
+|          |                                                                  |                                                                                                         |
+| -------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| baseType | optional “Enum” \| “IntEnum” \| “StrEnum” \| “Flag” \| “IntFlag” | The base type of the enum. One of: ‘Enum’, ‘IntEnum’, ‘StrEnum’, ‘Flag’, ‘IntFlag’. Defaults to ‘Enum’. |
+| doc      | optional [Children](../../../core/types/children/)               | Optional docstring for the enum.                                                                        |
+| members  | optional Array<[EnumMemberProps](../../components/enummember/)>  | Members of the enum as an array of objects.                                                             |

package/docs/api/types/GoogleStyleDocAttributeProps.md

@@ -0,0 +1,9 @@
+# GoogleStyleDocAttributeProps
+
+## Members
+
+|          |                                                    |   |
+| -------- | -------------------------------------------------- | - |
+| children | optional [Children](../../../core/types/children/) |   |
+| name     | [Children](../../../core/types/children/)          |   |
+| type     | optional [Children](../../../core/types/children/) |   |

package/docs/api/types/ImportRecordProps.md

@@ -0,0 +1,7 @@
+# ImportRecordProps
+
+## Members
+
+|         |                                           |   |
+| ------- | ----------------------------------------- | - |
+| symbols | Set<[ImportedSymbol](../importedsymbol/)> |   |

package/docs/api/types/ImportRecords.md

@@ -0,0 +1,8 @@
+# ImportRecords
+
+## Members
+
+Extends Map<[PythonModuleScope](../pythonmodulescope/), [ImportRecordProps](../importrecordprops/)>
+
+|   |
+| - |

package/docs/api/types/ImportedSymbol.md

@@ -0,0 +1,10 @@
+# ImportedSymbol
+
+## Members
+
+|             |                                                                           |                                                         |
+| ----------- | ------------------------------------------------------------------------- | ------------------------------------------------------- |
+| constructor | (target: PythonOutputSymbol, local: PythonOutputSymbol)                   | Constructs a new instance of the [`ImportedSymbol`](ImportedSymbol.md) class |
+| from        | (target: PythonOutputSymbol, local: PythonOutputSymbol) => ImportedSymbol |                                                         |
+| local       | [PythonOutputSymbol](../pythonoutputsymbol/)                              |                                                         |
+| target      | [PythonOutputSymbol](../pythonoutputsymbol/)                              |                                                         |

package/docs/api/types/LexicalScopeProps.md

@@ -0,0 +1,5 @@
+# LexicalScopeProps
+
+```ts
+type LexicalScopeProps = LexicalScopePropsWithScopeValue | LeixcalScopePropsWithScopeInfo;
+```

package/docs/api/types/MemberExpressionPartProps.md

@@ -0,0 +1,13 @@
+# MemberExpressionPartProps
+
+## Members
+
+|        |                                                                                                                                                                     |                                                                                                                    |
+| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| args   | optional [Children](../../../core/types/children/)\[] \| boolean                                                                                                    | Arguments to construct a call expression.                                                                          |
+| id     | optional string \| number                                                                                                                                           | The identifier for attribute access (obj.attr). Use this for Python attribute references.                          |
+| key    | optional [Children](../../../core/types/children/)                                                                                                                  | Single key for subscription access (obj\[key] or obj\[0]). Use this for single subscription access.                |
+| keys   | optional [Children](../../../core/types/children/)\[]                                                                                                               | Multiple keys for tuple subscription access (obj\[a, b] -> obj\[(a, b)]). Use this when you need tuple key access. |
+| refkey | optional [Refkey](../../../core/types/refkey/)                                                                                                                      | A refkey for a symbol whose name becomes the identifier.                                                           |
+| slice  | optional { start?: [Children](../../../core/types/children/); stop?: [Children](../../../core/types/children/); step?: [Children](../../../core/types/children/); } | Slice notation for subscription access (obj\[start:stop:step]). Use this for Python slice syntax.                  |
+| symbol | optional [OutputSymbol](../../../core/types/outputsymbol/)                                                                                                          | A symbol whose name becomes the identifier.                                                                        |

package/docs/api/types/ModuleDescriptor.md

@@ -0,0 +1,7 @@
+# ModuleDescriptor
+
+## Members
+
+|         |                             |   |
+| ------- | --------------------------- | - |
+| Indexer | \[path: string]: string\[]; |   |

package/docs/api/types/ModuleRefkeys.md

@@ -0,0 +1,7 @@
+# ModuleRefkeys
+
+```ts
+type ModuleRefkeys<PD extends Record<string, string[]>> = {
+    [P in keyof PD]: NamedMap<PD[P]>;
+};
+```

package/docs/api/types/NamedMap.md

@@ -0,0 +1,7 @@
+# NamedMap
+
+```ts
+type NamedMap<TDescriptor extends readonly string[]> = {
+    [S in TDescriptor[number]]: Refkey;
+};
+```

package/docs/api/types/ParameterDescriptor.md

@@ -0,0 +1,13 @@
+# ParameterDescriptor
+
+Information for a Python function parameter.
+
+## Members
+
+|         |                                                                                            |                                     |
+| ------- | ------------------------------------------------------------------------------------------ | ----------------------------------- |
+| default | optional [Children](../../../core/types/children/)                                         | The default value of the parameter. |
+| doc     | optional [Children](../../../core/types/children/)                                         | Documentation for the parameter.    |
+| name    | string \| [Namekey](../../../core/types/namekey/)                                          | The name of the parameter.          |
+| refkey  | optional [Refkey](../../../core/types/refkey/) \| [Refkey](../../../core/types/refkey/)\[] | The refkey for this parameter.      |
+| type    | optional [Children](../../../core/types/children/)                                         | The type of the parameter.          |

package/docs/api/types/ParameterMarker.md

@@ -0,0 +1,5 @@
+# ParameterMarker
+
+```ts
+type ParameterMarker = "*" | "/";
+```

package/docs/api/types/PropertyMethodDeclarationProps.md

@@ -0,0 +1,9 @@
+# PropertyMethodDeclarationProps
+
+## Members
+
+Extends Omit<[CommonFunctionProps](../commonfunctionprops/), “name”>
+
+|          |                  |   |
+| -------- | ---------------- | - |
+| abstract | optional boolean |   |