LiveState.yml

### YamlMime:TSType
name: LiveState
uid: '@microsoft/live-share.LiveState'
package: '@microsoft/live-share'
summary: >-
  Live fluid object that synchronizes a named state and optional data value
  across clients.
fullName: LiveState<TState>
remarks: >-
  The primary benefit of using the `LiveState` object in a Teams meeting, versus
  something

  like a `SharedMap`, is that you can restrict the roles of who's allowed to
  perform state

  changes.
isDeprecated: false
type: class
constructors:
  - name: 'LiveState<TState>(IDataObjectProps<{ Events: ILiveStateEvents<TState> }>)'
    uid: '@microsoft/live-share.LiveState.constructor'
    package: '@microsoft/live-share'
    summary: ''
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        new LiveState(props: IDataObjectProps<{ Events: ILiveStateEvents<TState>
        }>)
      parameters:
        - id: props
          type: 'IDataObjectProps&lt;{ Events: ILiveStateEvents&lt;TState&gt; }&gt;'
          description: ''
properties:
  - name: disposed
    uid: '@microsoft/live-share.LiveState.disposed'
    package: '@microsoft/live-share'
    summary: ''
    fullName: disposed
    remarks: ''
    isDeprecated: false
    syntax:
      content: boolean disposed
      return:
        description: ''
        type: boolean
  - name: factory
    uid: '@microsoft/live-share.LiveState.factory'
    package: '@microsoft/live-share'
    summary: The objects fluid type factory.
    fullName: factory
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'static factory: DataObjectFactory<LiveState<any>, DataObjectTypes>'
      return:
        description: ''
        type: >-
          DataObjectFactory&lt;<xref uid="@microsoft/live-share.LiveState"
          />&lt;any&gt;, DataObjectTypes&gt;
  - name: handle
    uid: '@microsoft/live-share.LiveState.handle'
    package: '@microsoft/live-share'
    summary: Handle to a data store
    fullName: handle
    remarks: ''
    isDeprecated: false
    syntax:
      content: IFluidHandle<this> handle
      return:
        description: ''
        type: IFluidHandle&lt;this&gt;
  - name: id
    uid: '@microsoft/live-share.LiveState.id'
    package: '@microsoft/live-share'
    summary: ''
    fullName: id
    remarks: ''
    isDeprecated: false
    syntax:
      content: string id
      return:
        description: ''
        type: string
  - name: IFluidHandle
    uid: '@microsoft/live-share.LiveState.IFluidHandle'
    package: '@microsoft/live-share'
    summary: ''
    fullName: IFluidHandle
    remarks: ''
    isDeprecated: false
    syntax:
      content: IFluidHandle<this> IFluidHandle
      return:
        description: ''
        type: IFluidHandle&lt;this&gt;
  - name: IFluidLoadable
    uid: '@microsoft/live-share.LiveState.IFluidLoadable'
    package: '@microsoft/live-share'
    summary: ''
    fullName: IFluidLoadable
    remarks: ''
    isDeprecated: false
    syntax:
      content: this IFluidLoadable
      return:
        description: ''
        type: this
  - name: IFluidRouter
    uid: '@microsoft/live-share.LiveState.IFluidRouter'
    package: '@microsoft/live-share'
    summary: ''
    fullName: IFluidRouter
    remarks: ''
    isDeprecated: false
    syntax:
      content: this IFluidRouter
      return:
        description: ''
        type: this
  - name: initializeState
    uid: '@microsoft/live-share.LiveState.initializeState'
    package: '@microsoft/live-share'
    summary: The initialization status of the data object.
    fullName: initializeState
    remarks: ''
    isDeprecated: false
    syntax:
      content: LiveDataObjectInitializeState initializeState
      return:
        description: ''
        type: <xref uid="@microsoft/live-share.LiveDataObjectInitializeState" />
  - name: isInitialized
    uid: '@microsoft/live-share.LiveState.isInitialized'
    package: '@microsoft/live-share'
    summary: Flag that indicates whether initialization has succeeded or not.
    fullName: isInitialized
    remarks: ''
    isDeprecated: false
    syntax:
      content: boolean isInitialized
      return:
        description: ''
        type: boolean
  - name: state
    uid: '@microsoft/live-share.LiveState.state'
    package: '@microsoft/live-share'
    summary: The current state.
    fullName: state
    remarks: ''
    isDeprecated: false
    syntax:
      content: TState state
      return:
        description: ''
        type: TState
  - name: TypeName
    uid: '@microsoft/live-share.LiveState.TypeName'
    package: '@microsoft/live-share'
    summary: The objects fluid type/name.
    fullName: TypeName
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        static TypeName: "@microsoft/live-share:LiveState" =
        "@microsoft/live-share:LiveState"
      return:
        description: ''
        type: '"@microsoft/live-share:LiveState"'
inheritedProperties:
  - name: addListener
    uid: '@microsoft/live-share.LiveState.addListener'
    package: '@microsoft/live-share'
    summary: ''
    fullName: addListener
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        addListener: TypedEventTransform<LiveState<TState>,
        ILiveStateEvents<TState> & IEvent>
      return:
        description: ''
        type: >-
          TypedEventTransform&lt;<xref uid="@microsoft/live-share.LiveState"
          />&lt;TState&gt;, <xref uid="@microsoft/live-share.ILiveStateEvents"
          />&lt;TState&gt; & IEvent&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.addListener](xref:@microsoft/live-share.LiveDataObject.addListener)
  - name: captureRejections
    uid: '@microsoft/live-share.LiveState.captureRejections'
    package: '@microsoft/live-share'
    summary: >-
      Value:
      [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type)


      Change the default `captureRejections` option on all new `EventEmitter`
      objects.
    fullName: captureRejections
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'static captureRejections: boolean'
      return:
        description: ''
        type: boolean
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.captureRejections](xref:@microsoft/live-share.LiveDataObject.captureRejections)
  - name: captureRejectionSymbol
    uid: '@microsoft/live-share.LiveState.captureRejectionSymbol'
    package: '@microsoft/live-share'
    summary: |-
      Value: `Symbol.for('nodejs.rejection')`

      See how to write a custom `rejection handler`.
    fullName: captureRejectionSymbol
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'static captureRejectionSymbol: typeof captureRejectionSymbol'
      return:
        description: ''
        type: typeof captureRejectionSymbol
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.captureRejectionSymbol](xref:@microsoft/live-share.LiveDataObject.captureRejectionSymbol)
  - name: defaultMaxListeners
    uid: '@microsoft/live-share.LiveState.defaultMaxListeners'
    package: '@microsoft/live-share'
    summary: >-
      By default, a maximum of `10` listeners can be registered for any single

      event. This limit can be changed for individual `EventEmitter` instances

      using the `emitter.setMaxListeners(n)` method. To change the default

      for _all_`EventEmitter` instances, the `events.defaultMaxListeners`
      property

      can be used. If this value is not a positive number, a `RangeError` is
      thrown.


      Take caution when setting the `events.defaultMaxListeners` because the

      change affects _all_ `EventEmitter` instances, including those created
      before

      the change is made. However, calling `emitter.setMaxListeners(n)` still
      has

      precedence over `events.defaultMaxListeners`.


      This is not a hard limit. The `EventEmitter` instance will allow

      more listeners to be added but will output a trace warning to stderr
      indicating

      that a "possible EventEmitter memory leak" has been detected. For any
      single

      `EventEmitter`, the `emitter.getMaxListeners()` and
      `emitter.setMaxListeners()` methods can be used to

      temporarily avoid this warning:


      ```js

      import { EventEmitter } from 'node:events';

      const emitter = new EventEmitter();

      emitter.setMaxListeners(emitter.getMaxListeners() + 1);

      emitter.once('event', () => {
        // do stuff
        emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
      });

      ```


      The `--trace-warnings` command-line flag can be used to display the

      stack trace for such warnings.


      The emitted warning can be inspected with `process.on('warning')` and will

      have the additional `emitter`, `type`, and `count` properties, referring
      to

      the event emitter instance, the event's name and the number of attached

      listeners, respectively.

      Its `name` property is set to `'MaxListenersExceededWarning'`.
    fullName: defaultMaxListeners
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'static defaultMaxListeners: number'
      return:
        description: ''
        type: number
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.defaultMaxListeners](xref:@microsoft/live-share.LiveDataObject.defaultMaxListeners)
  - name: errorMonitor
    uid: '@microsoft/live-share.LiveState.errorMonitor'
    package: '@microsoft/live-share'
    summary: >-
      This symbol shall be used to install a listener for only monitoring
      `'error'` events. Listeners installed using this symbol are called before
      the regular `'error'` listeners are called.


      Installing a listener using this symbol does not change the behavior once
      an `'error'` event is emitted. Therefore, the process will still crash if
      no

      regular `'error'` listener is installed.
    fullName: errorMonitor
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'static errorMonitor: typeof errorMonitor'
      return:
        description: ''
        type: typeof errorMonitor
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.errorMonitor](xref:@microsoft/live-share.LiveDataObject.errorMonitor)
  - name: 'off'
    uid: '@microsoft/live-share.LiveState.off'
    package: '@microsoft/live-share'
    summary: ''
    fullName: 'off'
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        off: TypedEventTransform<LiveState<TState>, ILiveStateEvents<TState> &
        IEvent>
      return:
        description: ''
        type: >-
          TypedEventTransform&lt;<xref uid="@microsoft/live-share.LiveState"
          />&lt;TState&gt;, <xref uid="@microsoft/live-share.ILiveStateEvents"
          />&lt;TState&gt; & IEvent&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.off](xref:@microsoft/live-share.LiveDataObject.off)
  - name: 'on'
    uid: '@microsoft/live-share.LiveState.on'
    package: '@microsoft/live-share'
    summary: ''
    fullName: 'on'
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        on: TypedEventTransform<LiveState<TState>, ILiveStateEvents<TState> &
        IEvent>
      return:
        description: ''
        type: >-
          TypedEventTransform&lt;<xref uid="@microsoft/live-share.LiveState"
          />&lt;TState&gt;, <xref uid="@microsoft/live-share.ILiveStateEvents"
          />&lt;TState&gt; & IEvent&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.on](xref:@microsoft/live-share.LiveDataObject.on)
  - name: once
    uid: '@microsoft/live-share.LiveState.once'
    package: '@microsoft/live-share'
    summary: ''
    fullName: once
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        once: TypedEventTransform<LiveState<TState>, ILiveStateEvents<TState> &
        IEvent>
      return:
        description: ''
        type: >-
          TypedEventTransform&lt;<xref uid="@microsoft/live-share.LiveState"
          />&lt;TState&gt;, <xref uid="@microsoft/live-share.ILiveStateEvents"
          />&lt;TState&gt; & IEvent&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.once](xref:@microsoft/live-share.LiveDataObject.once)
  - name: prependListener
    uid: '@microsoft/live-share.LiveState.prependListener'
    package: '@microsoft/live-share'
    summary: ''
    fullName: prependListener
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        prependListener: TypedEventTransform<LiveState<TState>,
        ILiveStateEvents<TState> & IEvent>
      return:
        description: ''
        type: >-
          TypedEventTransform&lt;<xref uid="@microsoft/live-share.LiveState"
          />&lt;TState&gt;, <xref uid="@microsoft/live-share.ILiveStateEvents"
          />&lt;TState&gt; & IEvent&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.prependListener](xref:@microsoft/live-share.LiveDataObject.prependListener)
  - name: prependOnceListener
    uid: '@microsoft/live-share.LiveState.prependOnceListener'
    package: '@microsoft/live-share'
    summary: ''
    fullName: prependOnceListener
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        prependOnceListener: TypedEventTransform<LiveState<TState>,
        ILiveStateEvents<TState> & IEvent>
      return:
        description: ''
        type: >-
          TypedEventTransform&lt;<xref uid="@microsoft/live-share.LiveState"
          />&lt;TState&gt;, <xref uid="@microsoft/live-share.ILiveStateEvents"
          />&lt;TState&gt; & IEvent&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.prependOnceListener](xref:@microsoft/live-share.LiveDataObject.prependOnceListener)
  - name: removeListener
    uid: '@microsoft/live-share.LiveState.removeListener'
    package: '@microsoft/live-share'
    summary: ''
    fullName: removeListener
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        removeListener: TypedEventTransform<LiveState<TState>,
        ILiveStateEvents<TState> & IEvent>
      return:
        description: ''
        type: >-
          TypedEventTransform&lt;<xref uid="@microsoft/live-share.LiveState"
          />&lt;TState&gt;, <xref uid="@microsoft/live-share.ILiveStateEvents"
          />&lt;TState&gt; & IEvent&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.removeListener](xref:@microsoft/live-share.LiveDataObject.removeListener)
inheritedMethods:
  - name: 'addAbortListener(AbortSignal, (event: Event) => void)'
    uid: '@microsoft/live-share.LiveState.addAbortListener'
    package: '@microsoft/live-share'
    summary: >-
      Listens once to the `abort` event on the provided `signal`.


      Listening to the `abort` event on abort signals is unsafe and may

      lead to resource leaks since another third party with the signal can

      call `e.stopImmediatePropagation()`. Unfortunately Node.js cannot change

      this since it would violate the web standard. Additionally, the original

      API makes it easy to forget to remove listeners.


      This API allows safely using `AbortSignal`s in Node.js APIs by solving
      these

      two issues by listening to the event such that `stopImmediatePropagation`
      does

      not prevent the listener from running.


      Returns a disposable so that it may be unsubscribed from more easily.


      ```js

      import { addAbortListener } from 'node:events';


      function example(signal) {
        let disposable;
        try {
          signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
          disposable = addAbortListener(signal, (e) => {
            // Do something when signal is aborted.
          });
        } finally {
          disposable?.[Symbol.dispose]();
        }
      }

      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        static function addAbortListener(signal: AbortSignal, resource: (event:
        Event) => void): Disposable
      parameters:
        - id: signal
          type: AbortSignal
          description: ''
        - id: resource
          type: '(event: Event) =&gt; void'
          description: ''
      return:
        description: Disposable that removes the `abort` listener.
        type: Disposable
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.addAbortListener](xref:@microsoft/live-share.LiveDataObject.addAbortListener)
  - name: emit<K>(string | symbol, AnyRest)
    uid: '@microsoft/live-share.LiveState.emit'
    package: '@microsoft/live-share'
    summary: >-
      Synchronously calls each of the listeners registered for the event named
      `eventName`, in the order they were registered, passing the supplied
      arguments

      to each.


      Returns `true` if the event had listeners, `false` otherwise.


      ```js

      import { EventEmitter } from 'node:events';

      const myEmitter = new EventEmitter();


      // First listener

      myEmitter.on('event', function firstListener() {
        console.log('Helloooo! first listener');
      });

      // Second listener

      myEmitter.on('event', function secondListener(arg1, arg2) {
        console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
      });

      // Third listener

      myEmitter.on('event', function thirdListener(...args) {
        const parameters = args.join(', ');
        console.log(`event with parameters ${parameters} in third listener`);
      });


      console.log(myEmitter.listeners('event'));


      myEmitter.emit('event', 1, 2, 3, 4, 5);


      // Prints:

      // [

      //   [Function: firstListener],

      //   [Function: secondListener],

      //   [Function: thirdListener]

      // ]

      // Helloooo! first listener

      // event with parameters 1, 2 in second listener

      // event with parameters 1, 2, 3, 4, 5 in third listener

      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function emit<K>(eventName: string | symbol, args: AnyRest): boolean'
      parameters:
        - id: eventName
          type: string | symbol
          description: ''
        - id: args
          type: AnyRest
          description: ''
      return:
        description: ''
        type: boolean
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.emit](xref:@microsoft/live-share.LiveDataObject.emit)
  - name: eventNames()
    uid: '@microsoft/live-share.LiveState.eventNames'
    package: '@microsoft/live-share'
    summary: |-
      Returns an array listing the events for which the emitter has registered
      listeners. The values in the array are strings or `Symbol`s.

      ```js
      import { EventEmitter } from 'node:events';

      const myEE = new EventEmitter();
      myEE.on('foo', () => {});
      myEE.on('bar', () => {});

      const sym = Symbol('symbol');
      myEE.on(sym, () => {});

      console.log(myEE.eventNames());
      // Prints: [ 'foo', 'bar', Symbol(symbol) ]
      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function eventNames(): (string | symbol)[]'
      return:
        description: ''
        type: (string | symbol)[]
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.eventNames](xref:@microsoft/live-share.LiveDataObject.eventNames)
  - name: finishInitialization(boolean)
    uid: '@microsoft/live-share.LiveState.finishInitialization'
    package: '@microsoft/live-share'
    summary: >-
      Call this API to ensure PureDataObject is fully initialized.

      Initialization happens on demand, only on as-needed bases.

      In most cases you should allow factory/object to decide when to finish
      initialization.

      But if you are supplying your own implementation of DataStoreRuntime
      factory and overriding some methods

      and need a fully initialized object, then you can call this API to ensure
      object is fully initialized.
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function finishInitialization(existing: boolean): Promise<void>'
      parameters:
        - id: existing
          type: boolean
          description: ''
      return:
        description: ''
        type: Promise&lt;void&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.finishInitialization](xref:@microsoft/live-share.LiveDataObject.finishInitialization)
  - name: getClientInfo(string)
    uid: '@microsoft/live-share.LiveState.getClientInfo'
    package: '@microsoft/live-share'
    summary: Get the client info for a given clientId
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        function getClientInfo(clientId: string): Promise<undefined |
        IClientInfo>
      parameters:
        - id: clientId
          type: string
          description: Fluid clientId we are requesting user info for
      return:
        description: >-
          IClientInfo object if the user is known, otherwise it will return
          undefined
        type: >-
          Promise&lt;undefined | <xref uid="@microsoft/live-share.IClientInfo"
          />&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.getClientInfo](xref:@microsoft/live-share.LiveDataObject.getClientInfo)
  - name: getDataObject(IFluidDataStoreRuntime)
    uid: '@microsoft/live-share.LiveState.getDataObject'
    package: '@microsoft/live-share'
    summary: ''
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        static function getDataObject(runtime: IFluidDataStoreRuntime):
        Promise<PureDataObject<DataObjectTypes>>
      parameters:
        - id: runtime
          type: IFluidDataStoreRuntime
          description: ''
      return:
        description: ''
        type: Promise&lt;PureDataObject&lt;DataObjectTypes&gt;&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.getDataObject](xref:@microsoft/live-share.LiveDataObject.getDataObject)
  - name: >-
      getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string |
      symbol)
    uid: '@microsoft/live-share.LiveState.getEventListeners'
    package: '@microsoft/live-share'
    summary: >-
      Returns a copy of the array of listeners for the event named `eventName`.


      For `EventEmitter`s this behaves exactly the same as calling `.listeners`
      on

      the emitter.


      For `EventTarget`s this is the only way to get the event listeners for the

      event target. This is useful for debugging and diagnostic purposes.


      ```js

      import { getEventListeners, EventEmitter } from 'node:events';


      {
        const ee = new EventEmitter();
        const listener = () => console.log('Events are fun');
        ee.on('foo', listener);
        console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
      }

      {
        const et = new EventTarget();
        const listener = () => console.log('Events are fun');
        et.addEventListener('foo', listener);
        console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
      }

      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        static function getEventListeners(emitter: EventEmitter<DefaultEventMap>
        | EventTarget, name: string | symbol): Function[]
      parameters:
        - id: emitter
          type: EventEmitter&lt;DefaultEventMap&gt; | EventTarget
          description: ''
        - id: name
          type: string | symbol
          description: ''
      return:
        description: ''
        type: Function[]
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.getEventListeners](xref:@microsoft/live-share.LiveDataObject.getEventListeners)
  - name: >-
      getFluidObjectFromDirectory<T>(string, IDirectory, (id: string, directory:
      IDirectory) => undefined | IFluidHandle<FluidObject<unknown> &
      IFluidLoadable>)
    uid: '@microsoft/live-share.LiveState.getFluidObjectFromDirectory'
    package: '@microsoft/live-share'
    summary: Retrieve Fluid object using the handle get
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        function getFluidObjectFromDirectory<T>(key: string, directory:
        IDirectory, getObjectFromDirectory?: (id: string, directory: IDirectory)
        => undefined | IFluidHandle<FluidObject<unknown> & IFluidLoadable>):
        Promise<undefined | T>
      parameters:
        - id: key
          type: string
          description: key that object (handle/id) is stored with in the directory
        - id: directory
          type: IDirectory
          description: directory containing the object
        - id: getObjectFromDirectory
          type: >-
            (id: string, directory: IDirectory) =&gt; undefined |
            IFluidHandle&lt;FluidObject&lt;unknown&gt; & IFluidLoadable&gt;
          description: >-
            optional callback for fetching object from the directory, allows
            users to

            define custom types/getters for object retrieval
      return:
        description: ''
        type: Promise&lt;undefined | T&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.getFluidObjectFromDirectory](xref:@microsoft/live-share.LiveDataObject.getFluidObjectFromDirectory)
  - name: getMaxListeners()
    uid: '@microsoft/live-share.LiveState.getMaxListeners'
    package: '@microsoft/live-share'
    summary: >-
      Returns the current max listener value for the `EventEmitter` which is
      either

      set by `emitter.setMaxListeners(n)` or defaults to
      [defaultMaxListeners](xref:@microsoft/live-share.LiveState.defaultMaxListeners).
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function getMaxListeners(): number'
      return:
        description: ''
        type: number
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.getMaxListeners](xref:@microsoft/live-share.LiveDataObject.getMaxListeners)
  - name: getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)
    uid: '@microsoft/live-share.LiveState.getMaxListeners'
    package: '@microsoft/live-share'
    summary: >-
      Returns the currently set max amount of listeners.


      For `EventEmitter`s this behaves exactly the same as calling
      `.getMaxListeners` on

      the emitter.


      For `EventTarget`s this is the only way to get the max event listeners for
      the

      event target. If the number of event handlers on a single EventTarget
      exceeds

      the max set, the EventTarget will print a warning.


      ```js

      import { getMaxListeners, setMaxListeners, EventEmitter } from
      'node:events';


      {
        const ee = new EventEmitter();
        console.log(getMaxListeners(ee)); // 10
        setMaxListeners(11, ee);
        console.log(getMaxListeners(ee)); // 11
      }

      {
        const et = new EventTarget();
        console.log(getMaxListeners(et)); // 10
        setMaxListeners(11, et);
        console.log(getMaxListeners(et)); // 11
      }

      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        static function getMaxListeners(emitter: EventEmitter<DefaultEventMap> |
        EventTarget): number
      parameters:
        - id: emitter
          type: EventEmitter&lt;DefaultEventMap&gt; | EventTarget
          description: ''
      return:
        description: ''
        type: number
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.getMaxListeners](xref:@microsoft/live-share.LiveDataObject.getMaxListeners)
  - name: initializeInternal(boolean)
    uid: '@microsoft/live-share.LiveState.initializeInternal'
    package: '@microsoft/live-share'
    summary: |-
      Initializes internal objects and calls initialization overrides.
      Caller is responsible for ensuring this is only invoked once.
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function initializeInternal(existing: boolean): Promise<void>'
      parameters:
        - id: existing
          type: boolean
          description: ''
      return:
        description: ''
        type: Promise&lt;void&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.initializeInternal](xref:@microsoft/live-share.LiveDataObject.initializeInternal)
  - name: listenerCount(EventEmitter<DefaultEventMap>, string | symbol)
    uid: '@microsoft/live-share.LiveState.listenerCount'
    package: '@microsoft/live-share'
    summary: >-
      A class method that returns the number of listeners for the given
      `eventName` registered on the given `emitter`.


      ```js

      import { EventEmitter, listenerCount } from 'node:events';


      const myEmitter = new EventEmitter();

      myEmitter.on('event', () => {});

      myEmitter.on('event', () => {});

      console.log(listenerCount(myEmitter, 'event'));

      // Prints: 2

      ```
    remarks: ''
    isDeprecated: true
    customDeprecatedMessage: Since v3.2.0 - Use `listenerCount` instead.
    syntax:
      content: >-
        static function listenerCount(emitter: EventEmitter<DefaultEventMap>,
        eventName: string | symbol): number
      parameters:
        - id: emitter
          type: EventEmitter&lt;DefaultEventMap&gt;
          description: The emitter to query
        - id: eventName
          type: string | symbol
          description: The event name
      return:
        description: ''
        type: number
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.listenerCount](xref:@microsoft/live-share.LiveDataObject.listenerCount)
  - name: listenerCount<K>(string | symbol, Function)
    uid: '@microsoft/live-share.LiveState.listenerCount'
    package: '@microsoft/live-share'
    summary: >-
      Returns the number of listeners listening for the event named `eventName`.

      If `listener` is provided, it will return how many times the listener is
      found

      in the list of the listeners of the event.
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        function listenerCount<K>(eventName: string | symbol, listener?:
        Function): number
      parameters:
        - id: eventName
          type: string | symbol
          description: The name of the event being listened for
        - id: listener
          type: Function
          description: The event handler function
      return:
        description: ''
        type: number
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.listenerCount](xref:@microsoft/live-share.LiveDataObject.listenerCount)
  - name: listeners<K>(string | symbol)
    uid: '@microsoft/live-share.LiveState.listeners'
    package: '@microsoft/live-share'
    summary: |-
      Returns a copy of the array of listeners for the event named `eventName`.

      ```js
      server.on('connection', (stream) => {
        console.log('someone connected!');
      });
      console.log(util.inspect(server.listeners('connection')));
      // Prints: [ [Function] ]
      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function listeners<K>(eventName: string | symbol): Function[]'
      parameters:
        - id: eventName
          type: string | symbol
          description: ''
      return:
        description: ''
        type: Function[]
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.listeners](xref:@microsoft/live-share.LiveDataObject.listeners)
  - name: on(EventEmitter<DefaultEventMap>, string, StaticEventEmitterOptions)
    uid: '@microsoft/live-share.LiveState.on'
    package: '@microsoft/live-share'
    summary: |-
      ```js
      import { on, EventEmitter } from 'node:events';
      import process from 'node:process';

      const ee = new EventEmitter();

      // Emit later on
      process.nextTick(() => {
        ee.emit('foo', 'bar');
        ee.emit('foo', 42);
      });

      for await (const event of on(ee, 'foo')) {
        // The execution of this inner block is synchronous and it
        // processes one event at a time (even with await). Do not use
        // if concurrent execution is required.
        console.log(event); // prints ['bar'] [42]
      }
      // Unreachable here
      ```

      Returns an `AsyncIterator` that iterates `eventName` events. It will throw
      if the `EventEmitter` emits `'error'`. It removes all listeners when
      exiting the loop. The `value` returned by each iteration is an array
      composed of the emitted event arguments.

      An `AbortSignal` can be used to cancel waiting on events:

      ```js
      import { on, EventEmitter } from 'node:events';
      import process from 'node:process';

      const ac = new AbortController();

      (async () => {
        const ee = new EventEmitter();

        // Emit later on
        process.nextTick(() => {
          ee.emit('foo', 'bar');
          ee.emit('foo', 42);
        });

        for await (const event of on(ee, 'foo', { signal: ac.signal })) {
          // The execution of this inner block is synchronous and it
          // processes one event at a time (even with await). Do not use
          // if concurrent execution is required.
          console.log(event); // prints ['bar'] [42]
        }
        // Unreachable here
      })();

      process.nextTick(() => ac.abort());
      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        static function on(emitter: EventEmitter<DefaultEventMap>, eventName:
        string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>
      parameters:
        - id: emitter
          type: EventEmitter&lt;DefaultEventMap&gt;
          description: ''
        - id: eventName
          type: string
          description: The name of the event being listened for
        - id: options
          type: StaticEventEmitterOptions
          description: ''
      return:
        description: >-
          An `AsyncIterator` that iterates `eventName` events emitted by the
          `emitter`
        type: AsyncIterableIterator&lt;any&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.on](xref:@microsoft/live-share.LiveDataObject.on)
  - name: >-
      once(EventEmitter<DefaultEventMap>, string | symbol,
      StaticEventEmitterOptions)
    uid: '@microsoft/live-share.LiveState.once'
    package: '@microsoft/live-share'
    summary: >-
      Creates a `Promise` that is fulfilled when the `EventEmitter` emits the
      given

      event or that is rejected if the `EventEmitter` emits `'error'` while
      waiting.

      The `Promise` will resolve with an array of all the arguments emitted to
      the

      given event.


      This method is intentionally generic and works with the web platform
      [EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget)
      interface, which has no special`'error'` event

      semantics and does not listen to the `'error'` event.


      ```js

      import { once, EventEmitter } from 'node:events';

      import process from 'node:process';


      const ee = new EventEmitter();


      process.nextTick(() => {
        ee.emit('myevent', 42);
      });


      const [value] = await once(ee, 'myevent');

      console.log(value);


      const err = new Error('kaboom');

      process.nextTick(() => {
        ee.emit('error', err);
      });


      try {
        await once(ee, 'myevent');
      } catch (err) {
        console.error('error happened', err);
      }

      ```


      The special handling of the `'error'` event is only used when
      `events.once()` is used to wait for another event. If `events.once()` is
      used to wait for the

      '`error'` event itself, then it is treated as any other kind of event
      without

      special handling:


      ```js

      import { EventEmitter, once } from 'node:events';


      const ee = new EventEmitter();


      once(ee, 'error')
        .then(([err]) => console.log('ok', err.message))
        .catch((err) => console.error('error', err.message));

      ee.emit('error', new Error('boom'));


      // Prints: ok boom

      ```


      An `AbortSignal` can be used to cancel waiting for the event:


      ```js

      import { EventEmitter, once } from 'node:events';


      const ee = new EventEmitter();

      const ac = new AbortController();


      async function foo(emitter, event, signal) {
        try {
          await once(emitter, event, { signal });
          console.log('event emitted!');
        } catch (error) {
          if (error.name === 'AbortError') {
            console.error('Waiting for the event was canceled!');
          } else {
            console.error('There was an error', error.message);
          }
        }
      }


      foo(ee, 'foo', ac.signal);

      ac.abort(); // Abort waiting for the event

      ee.emit('foo'); // Prints: Waiting for the event was canceled!

      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        static function once(emitter: EventEmitter<DefaultEventMap>, eventName:
        string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>
      parameters:
        - id: emitter
          type: EventEmitter&lt;DefaultEventMap&gt;
          description: ''
        - id: eventName
          type: string | symbol
          description: ''
        - id: options
          type: StaticEventEmitterOptions
          description: ''
      return:
        description: ''
        type: Promise&lt;any[]&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.once](xref:@microsoft/live-share.LiveDataObject.once)
  - name: once(EventTarget, string, StaticEventEmitterOptions)
    uid: '@microsoft/live-share.LiveState.once_1'
    package: '@microsoft/live-share'
    summary: ''
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        static function once(emitter: EventTarget, eventName: string, options?:
        StaticEventEmitterOptions): Promise<any[]>
      parameters:
        - id: emitter
          type: EventTarget
          description: ''
        - id: eventName
          type: string
          description: ''
        - id: options
          type: StaticEventEmitterOptions
          description: ''
      return:
        description: ''
        type: Promise&lt;any[]&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.once](xref:@microsoft/live-share.LiveDataObject.once)
  - name: rawListeners<K>(string | symbol)
    uid: '@microsoft/live-share.LiveState.rawListeners'
    package: '@microsoft/live-share'
    summary: |-
      Returns a copy of the array of listeners for the event named `eventName`,
      including any wrappers (such as those created by `.once()`).

      ```js
      import { EventEmitter } from 'node:events';
      const emitter = new EventEmitter();
      emitter.once('log', () => console.log('log once'));

      // Returns a new Array with a function `onceWrapper` which has a property
      // `listener` which contains the original listener bound above
      const listeners = emitter.rawListeners('log');
      const logFnWrapper = listeners[0];

      // Logs "log once" to the console and does not unbind the `once` event
      logFnWrapper.listener();

      // Logs "log once" to the console and removes the listener
      logFnWrapper();

      emitter.on('log', () => console.log('log persistently'));
      // Will return a new Array with a single function bound by `.on()` above
      const newListeners = emitter.rawListeners('log');

      // Logs "log persistently" twice
      newListeners[0]();
      emitter.emit('log');
      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function rawListeners<K>(eventName: string | symbol): Function[]'
      parameters:
        - id: eventName
          type: string | symbol
          description: ''
      return:
        description: ''
        type: Function[]
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.rawListeners](xref:@microsoft/live-share.LiveDataObject.rawListeners)
  - name: removeAllListeners(string | symbol)
    uid: '@microsoft/live-share.LiveState.removeAllListeners'
    package: '@microsoft/live-share'
    summary: |-
      Removes all listeners, or those of the specified `eventName`.

      It is bad practice to remove listeners added elsewhere in the code,
      particularly when the `EventEmitter` instance was created by some other
      component or module (e.g. sockets or file streams).

      Returns a reference to the `EventEmitter`, so that calls can be chained.
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        function removeAllListeners(eventName?: string | symbol):
        LiveState<TState>
      parameters:
        - id: eventName
          type: string | symbol
          description: ''
      return:
        description: ''
        type: <xref uid="@microsoft/live-share.LiveState" />&lt;TState&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.removeAllListeners](xref:@microsoft/live-share.LiveDataObject.removeAllListeners)
  - name: request(IRequest)
    uid: '@microsoft/live-share.LiveState.request'
    package: '@microsoft/live-share'
    summary: '{@inheritDoc PureDataObject.request}'
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function request(request: IRequest): Promise<IResponse>'
      parameters:
        - id: request
          type: IRequest
          description: ''
      return:
        description: ''
        type: Promise&lt;IResponse&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.request](xref:@microsoft/live-share.LiveDataObject.request)
  - name: setMaxListeners(number)
    uid: '@microsoft/live-share.LiveState.setMaxListeners'
    package: '@microsoft/live-share'
    summary: >-
      By default `EventEmitter`s will print a warning if more than `10`
      listeners are

      added for a particular event. This is a useful default that helps finding

      memory leaks. The `emitter.setMaxListeners()` method allows the limit to
      be

      modified for this specific `EventEmitter` instance. The value can be set
      to `Infinity` (or `0`) to indicate an unlimited number of listeners.


      Returns a reference to the `EventEmitter`, so that calls can be chained.
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function setMaxListeners(n: number): LiveState<TState>'
      parameters:
        - id: 'n'
          type: number
          description: ''
      return:
        description: ''
        type: <xref uid="@microsoft/live-share.LiveState" />&lt;TState&gt;
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.setMaxListeners](xref:@microsoft/live-share.LiveDataObject.setMaxListeners)
  - name: setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[])
    uid: '@microsoft/live-share.LiveState.setMaxListeners'
    package: '@microsoft/live-share'
    summary: |-
      ```js
      import { setMaxListeners, EventEmitter } from 'node:events';

      const target = new EventTarget();
      const emitter = new EventEmitter();

      setMaxListeners(5, target, emitter);
      ```
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        static function setMaxListeners(n?: number, eventTargets:
        (EventEmitter<DefaultEventMap> | EventTarget)[])
      parameters:
        - id: 'n'
          type: number
          description: >-
            A non-negative number. The maximum number of listeners per
            `EventTarget` event.
        - id: eventTargets
          type: (EventEmitter&lt;DefaultEventMap&gt; | EventTarget)[]
          description: ''
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.setMaxListeners](xref:@microsoft/live-share.LiveDataObject.setMaxListeners)
  - name: '[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)'
    uid: '@microsoft/live-share.LiveState.[captureRejectionSymbol]'
    package: '@microsoft/live-share'
    summary: ''
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        function [captureRejectionSymbol]<K>(error: Error, event: string |
        symbol, args: AnyRest)
      parameters:
        - id: error
          type: Error
          description: ''
        - id: event
          type: string | symbol
          description: ''
        - id: args
          type: AnyRest
          description: ''
    inheritanceDescription: >-
      <b>Inherited From</b>
      [LiveDataObject.[captureRejectionSymbol]](xref:@microsoft/live-share.LiveDataObject.[captureRejectionSymbol])
methods:
  - name: dispose()
    uid: '@microsoft/live-share.LiveState.dispose'
    package: '@microsoft/live-share'
    summary: Disposes of the object when its container is disposed of.
    remarks: ''
    isDeprecated: false
    syntax:
      content: function dispose()
  - name: initialize(TState, UserMeetingRole[])
    uid: '@microsoft/live-share.LiveState.initialize'
    package: '@microsoft/live-share'
    summary: >-
      Initialize the object to begin sending/receiving state updates through
      this DDS.
    remarks: ''
    isDeprecated: false
    syntax:
      content: >-
        function initialize(initialState: TState, allowedRoles?:
        UserMeetingRole[]): Promise<void>
      parameters:
        - id: initialState
          type: TState
          description: Initial state value
        - id: allowedRoles
          type: <xref uid="@microsoft/live-share.UserMeetingRole" />[]
          description: Optional. List of roles allowed to make state changes.
      return:
        description: a void promise that resolves once complete
        type: Promise&lt;void&gt;
  - name: set(TState)
    uid: '@microsoft/live-share.LiveState.set'
    package: '@microsoft/live-share'
    summary: Set a new state value
    remarks: ''
    isDeprecated: false
    syntax:
      content: 'function set(state: TState): Promise<void>'
      parameters:
        - id: state
          type: TState
          description: New state value.
      return:
        description: >-
          a void promise that resolves once the set event has been sent to the
          server.
        type: Promise&lt;void&gt;
extends: >-
  <xref uid="@microsoft/live-share.LiveDataObject" />&lt;{ Events:
  ILiveStateEvents&lt;TState&gt; }&gt;