# createPrivateStaticMemberSymbol

```ts
import { createPrivateStaticMemberSymbol } from "@alloy-js/typescript";


function createPrivateStaticMemberSymbol(name: string | Namekey, options?: CreateTsSymbolOptions): TSOutputSymbol;
```

## Parameters

|         |                                |   |
| ------- | ------------------------------ | - |
| name    | string \| Namekey              |   |
| options | optional CreateTsSymbolOptions |   |

## 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. |
| default               | optional boolean                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| export                | optional boolean                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| hasInstanceMembers    | optional boolean                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| tsFlags               | optional[TSSymbolFlags](../../variables/tssymbolflags/)                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 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

[TSOutputSymbol](../../types/tsoutputsymbol/)