Class Conductor

The Conductor class serves as the main class for interacting. It contains methods for setting mappings, timelines and adding/removing devices. It keeps track of when to resolve the timeline and updates the devices with new states.

Hierarchy

EventEmitter<ConductorEvents>
- Conductor

Index

Constructors

constructor

Accessors

estimateResolveTimeMultiplier logDebug mapping timeline timelineHash

Constructors

constructor

new Conductor(options?: ConductorOptions): Conductor
Parameters
- options: ConductorOptions = {}
Returns Conductor
Overrides EventEmitter<ConductorEvents>.constructor
- Defined in packages/timeline-state-resolver/src/conductor.ts:221

Properties

`Private` _actionQueue

_actionQueue: default<default, DefaultAddOptions> = ...

`Private` _callbackInstances

_callbackInstances: Map<string, CallbackInstance> = ...

`Private` _datastore

_datastore: Datastore = {}

`Private` _deviceStates

_deviceStates: {
[deviceId: string]: DeviceState[];
} = {}

Type declaration

[deviceId: string]: DeviceState[]

`Private` _doOnTime

_doOnTime: DoOnTime

`Private` _estimateResolveTimeMultiplier

_estimateResolveTimeMultiplier: number = 1

`Private` `Optional` _getCurrentTime

_getCurrentTime?: (() => number)

Type declaration

- (): number
- Returns number

`Private` _interval

_interval: Timer

`Private` _isInitialized

_isInitialized: boolean = false

`Private` _logDebug

_logDebug: boolean = false

`Private` _mappings

_mappings: Mappings<unknown> = {}

`Private` _multiThreadedResolver

_multiThreadedResolver: boolean = false

`Private` _nextResolveTime

_nextResolveTime: number = 0

`Private` _options

_options: ConductorOptions

`Private` _resolveTimelineTrigger

_resolveTimelineTrigger: undefined | Timer

`Private` _resolved

_resolved: {
    resolveTime: number;
    resolvedTimeline: null | ResolvedTimeline<TSRTimelineContent>;
    validTo: number;
} = ...

Type declaration

resolveTime: number

Timestamp, when the timeline was resolved
resolvedTimeline: null | ResolvedTimeline<TSRTimelineContent>
validTo: number

Timestamp, when the timeline needs to be re-resolved

`Private` _resolver

_resolver: Promisify<AsyncResolver>

`Private` _sentCallbacks

_sentCallbacks: TimelineCallbacks = {}

`Private` _statMeasureReason

_statMeasureReason: string = ''

`Private` _statMeasureStart

_statMeasureStart: number = 0

`Private` _statReports

_statReports: StatReport[] = []

`Private` _timeline

_timeline: TSRTimeline = []

`Private` _timelineHash

_timelineHash: undefined | string

`Private` _timelineSize

_timelineSize: undefined | number = undefined

`Private` _triggerSendStartStopCallbacksTimeout

_triggerSendStartStopCallbacksTimeout: null | Timer = null

`Private` _useCacheWhenResolving

_useCacheWhenResolving: boolean = false

`Private` activationId

activationId: undefined | string

`Private` devices

devices: Map<string, BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>> = ...

Accessors

estimateResolveTimeMultiplier

get estimateResolveTimeMultiplier(): number
Returns number
- Defined in packages/timeline-state-resolver/src/conductor.ts:338
set estimateResolveTimeMultiplier(value: number): void
Parameters
- value: number
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:341

logDebug

get logDebug(): boolean
Returns boolean
- Defined in packages/timeline-state-resolver/src/conductor.ts:330
set logDebug(val: boolean): void
Parameters
- val: boolean
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:333

mapping

get mapping(): Mappings<unknown>
Returns the mappings

Returns Mappings<unknown>
- Defined in packages/timeline-state-resolver/src/conductor.ts:300

timeline

get timeline(): TSRTimeline
Returns the current timeline

Returns TSRTimeline
- Defined in packages/timeline-state-resolver/src/conductor.ts:306

timelineHash

get timelineHash(): undefined | string
Returns undefined | string
- Defined in packages/timeline-state-resolver/src/conductor.ts:324
set timelineHash(hash: undefined | string): void
Parameters
- hash: undefined | string
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:327

Methods

`Private` _diffStateForCallbacks

_diffStateForCallbacks(activeObjects: TimelineCallbacks, tlTime: number): void
Parameters
- activeObjects: TimelineCallbacks
- tlTime: number
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:1259

`Private` _mapAllDevices

_mapAllDevices<T>(includeUninitialized: boolean, fcn: ((d: BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>) => Promise<T>)): Promise<T[]>
Type Parameters
- T
Parameters
- includeUninitialized: boolean
- fcn: ((d: BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>) => Promise<T>)
  - - (d: BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>): Promise<T>
    - Parameters
      
      d: BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>
      
      Returns Promise<T>
Returns Promise<T[]>
- Defined in packages/timeline-state-resolver/src/conductor.ts:754

`Private` _queueCallback

_queueCallback(playing: boolean, cb: QueueCallback): void
Parameters
- playing: boolean
- cb: QueueCallback
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:1299

`Private` _resolveTimeline

_resolveTimeline(): void
Resolves the timeline for the next resolve-time, generates the commands and passes on the commands.

Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:793

`Private` _resolveTimelineInner

_resolveTimelineInner(): Promise<undefined | number>
Returns Promise<undefined | number>
- Defined in packages/timeline-state-resolver/src/conductor.ts:810

`Private` _sendStartStopCallbacks

_sendStartStopCallbacks(): void
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:1366

`Private` _setDeviceState

_setDeviceState(deviceId: string, time: number, state: Timeline.TimelineState<TSRTimelineContent>, unfilteredMappings: Mappings<unknown>): Promise<undefined | void>
Parameters
- deviceId: string
- time: number
- state: Timeline.TimelineState<TSRTimelineContent>
- unfilteredMappings: Mappings<unknown>
Returns Promise<undefined | void>
- Defined in packages/timeline-state-resolver/src/conductor.ts:1110

`Private` _triggerResolveTimeline

_triggerResolveTimeline(timeUntilTrigger?: number): void
This is the main resolve-loop.
Parameters
- Optional timeUntilTrigger: number
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:771

`Private` _triggerSendStartStopCallbacks

_triggerSendStartStopCallbacks(): void
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:1357

addDevice

addDevice(deviceId: string, deviceOptions: DeviceOptionsAnyInternal, activeRundownPlaylistId?: string): Promise<BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>>
Adds a device that can be referenced by the timeline and mappings. NOTE: use this with caution! if a device fails to initialise (i.e. because the hardware is turned off) this may never resolve. It is preferred to use createDevice and initDevice separately for this reason.

Returns
A promise that resolves with the created device, or rejects with an error message.
Parameters
- deviceId: string
  
  Id used by the mappings to reference the device.
- deviceOptions: DeviceOptionsAnyInternal
  
  The options used to initalize the device
- Optional activeRundownPlaylistId: string
Returns Promise<BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>>
- Defined in packages/timeline-state-resolver/src/conductor.ts:376

addListener

addListener<T>(event: T, fn: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void), context?: any): Conductor
Type Parameters
- T extends keyof ConductorEvents
Parameters
- event: T
- fn: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void)
  - - (...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]): void
    - Parameters
      
      Rest ...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]
      
      Returns void
- Optional context: any
Returns Conductor
Inherited from EventEmitter.addListener
- Defined in node_modules/eventemitter3/index.d.ts:45

createDevice

createDevice(deviceId: string, deviceOptions: DeviceOptionsAnyInternal, options?: {
signal?: AbortSignal;
}): Promise<BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>>
Creates an uninitialised device that can be referenced by the timeline and mappings.

Returns
A promise that resolves with the created device, or rejects with an error message.
Parameters
- deviceId: string
  
  Id used by the mappings to reference the device.
- deviceOptions: DeviceOptionsAnyInternal
  
  The options used to initalize the device
- Optional options: {
  signal?: AbortSignal;
  }
  
  Additional options
  - Optional signal?: AbortSignal
Returns Promise<BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>>
- Defined in packages/timeline-state-resolver/src/conductor.ts:433

`Private` createDeviceContainer

createDeviceContainer(deviceOptions: DeviceOptionsAnyInternal, deviceId: string, getCurrentTime: (() => number), threadedClassOptions: ThreadedClassConfig): null | Promise<BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>>
Parameters
- deviceOptions: DeviceOptionsAnyInternal
- deviceId: string
- getCurrentTime: (() => number)
  - - (): number
    - Returns number
- threadedClassOptions: ThreadedClassConfig
Returns null | Promise<BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>>
- Defined in packages/timeline-state-resolver/src/conductor.ts:505

destroy

destroy(): Promise<void>
Remove all devices

Returns Promise<void>
- Defined in packages/timeline-state-resolver/src/conductor.ts:667

devicesMakeReady

devicesMakeReady(okToDestroyStuff?: boolean, activationId?: string): Promise<void>
Send a makeReady-trigger to all devices

Deprecated
replace by TSR actions
Parameters
- Optional okToDestroyStuff: boolean
- Optional activationId: string
Returns Promise<void>
- Defined in packages/timeline-state-resolver/src/conductor.ts:702

devicesStandDown

devicesStandDown(okToDestroyStuff?: boolean): Promise<void>
Send a standDown-trigger to all devices

Deprecated
replaced by TSR actions
Parameters
- Optional okToDestroyStuff: boolean
Returns Promise<void>
- Defined in packages/timeline-state-resolver/src/conductor.ts:732

emit

emit<T>(event: T, ...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]): boolean
Calls each of the listeners registered for a given event.
Type Parameters
- T extends keyof ConductorEvents
Parameters
- event: T
- Rest ...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]
Returns boolean
Inherited from EventEmitter.emit
- Defined in node_modules/eventemitter3/index.d.ts:32

`Private` emitWhenActive

emitWhenActive(eventType: keyof ConductorEvents, ...args: any[]): void
Only emits the event when there is an active rundownPlaylist. This is used to reduce unnesessary logging
Parameters
- eventType: keyof ConductorEvents
- Rest ...args: any[]
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:1488

estimateResolveTime

estimateResolveTime(): number
Returns a time estimate for the resolval duration based on the amount of objects on the timeline. If the proActiveResolve option is falsy this returns 0.

Returns number
- Defined in packages/timeline-state-resolver/src/conductor.ts:1224

eventNames

eventNames(): (keyof ConductorEvents)[]
Return an array listing the events for which the emitter has registered listeners.

Returns (keyof ConductorEvents)[]
Inherited from EventEmitter.eventNames
- Defined in node_modules/eventemitter3/index.d.ts:15

`Private` filterLayersPerDevice

filterLayersPerDevice(layers: Timeline.StateInTime<TSRTimelineContent>, devices: BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>[]): {
    [deviceId: string]: {
        [layerId: string]: ResolvedTimelineObjectInstanceExtended;
    };
}
Split the state into substates that are relevant for each device
Parameters
- layers: Timeline.StateInTime<TSRTimelineContent>
- devices: BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>[]
Returns {
    [deviceId: string]: {
        [layerId: string]: ResolvedTimelineObjectInstanceExtended;
    };
}
- [deviceId: string]: {
  [layerId: string]: ResolvedTimelineObjectInstanceExtended;
  }
  - [layerId: string]: ResolvedTimelineObjectInstanceExtended
- Defined in packages/timeline-state-resolver/src/conductor.ts:1453

getCurrentTime

getCurrentTime(): number
Returns a nice, synchronized time.

Returns number
- Defined in packages/timeline-state-resolver/src/conductor.ts:290

getDevice

getDevice(deviceId: string, includeUninitialized?: boolean): undefined | BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>
Parameters
- deviceId: string
- includeUninitialized: boolean = false
Returns undefined | BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>
- Defined in packages/timeline-state-resolver/src/conductor.ts:353

getDevices

getDevices(includeUninitialized?: boolean): BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>[]
Parameters
- includeUninitialized: boolean = false
Returns BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>[]
- Defined in packages/timeline-state-resolver/src/conductor.ts:345

getThreadsMemoryUsage

getThreadsMemoryUsage(): Promise<{
[childId: string]: MemUsageReport;
}>
Returns Promise<{
[childId: string]: MemUsageReport;
}>
- Defined in packages/timeline-state-resolver/src/conductor.ts:750

getTimelineSize

getTimelineSize(): number
Returns number
- Defined in packages/timeline-state-resolver/src/conductor.ts:1197

`Private` getTimelineSizeInner

getTimelineSizeInner(timelineObjects: TSRTimelineObj<any>[]): number
Parameters
- timelineObjects: TSRTimelineObj<any>[]
Returns number
- Defined in packages/timeline-state-resolver/src/conductor.ts:1205

init

init(): Promise<void>
Initializates the resolver, with optional multithreading

Returns Promise<void>
- Defined in packages/timeline-state-resolver/src/conductor.ts:253

initDevice

initDevice(deviceId: string, deviceOptions: DeviceOptionsAnyInternal, activeRundownPlaylistId?: string, options?: {
signal?: AbortSignal;
}): Promise<BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>>
Initialises an existing device that can be referenced by the timeline and mappings.

Returns
A promise that resolves with the initialised device, or rejects with an error message.
Parameters
- deviceId: string
  
  Id used by the mappings to reference the device.
- deviceOptions: DeviceOptionsAnyInternal
  
  The options used to initalize the device
- Optional activeRundownPlaylistId: string
  
  Id of the current rundown playlist
- Optional options: {
  signal?: AbortSignal;
  }
  
  Additional options
  - Optional signal?: AbortSignal
Returns Promise<BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>>
- Defined in packages/timeline-state-resolver/src/conductor.ts:607

listenerCount

listenerCount(event: keyof ConductorEvents): number
Return the number of listeners listening to a given event.
Parameters
- event: keyof ConductorEvents
Returns number
Inherited from EventEmitter.listenerCount
- Defined in node_modules/eventemitter3/index.d.ts:27

listeners

listeners<T>(event: T): ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void)[]
Return the listeners registered for a given event.
Type Parameters
- T extends keyof ConductorEvents
Parameters
- event: T
Returns ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void)[]
Inherited from EventEmitter.listeners
- Defined in node_modules/eventemitter3/index.d.ts:20

off

off<T>(event: T, fn?: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void), context?: any, once?: boolean): Conductor
Type Parameters
- T extends keyof ConductorEvents
Parameters
- event: T
- Optional fn: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void)
  - - (...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]): void
    - Parameters
      
      Rest ...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]
      
      Returns void
- Optional context: any
- Optional once: boolean
Returns Conductor
Inherited from EventEmitter.off
- Defined in node_modules/eventemitter3/index.d.ts:69

on

on<T>(event: T, fn: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void), context?: any): Conductor
Add a listener for a given event.
Type Parameters
- T extends keyof ConductorEvents
Parameters
- event: T
- fn: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void)
  - - (...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]): void
    - Parameters
      
      Rest ...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]
      
      Returns void
- Optional context: any
Returns Conductor
Inherited from EventEmitter.on
- Defined in node_modules/eventemitter3/index.d.ts:40

once

once<T>(event: T, fn: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void), context?: any): Conductor
Add a one-time listener for a given event.
Type Parameters
- T extends keyof ConductorEvents
Parameters
- event: T
- fn: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void)
  - - (...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]): void
    - Parameters
      
      Rest ...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]
      
      Returns void
- Optional context: any
Returns Conductor
Inherited from EventEmitter.once
- Defined in node_modules/eventemitter3/index.d.ts:54

removeAllListeners

removeAllListeners(event?: keyof ConductorEvents): Conductor
Remove all listeners, or those of the specified event.
Parameters
- Optional event: keyof ConductorEvents
Returns Conductor
Inherited from EventEmitter.removeAllListeners
- Defined in node_modules/eventemitter3/index.d.ts:79

removeDevice

removeDevice(deviceId: string): Promise<void>
Safely remove a device
Parameters
- deviceId: string
  
  The id of the device to be removed
Returns Promise<void>
- Defined in packages/timeline-state-resolver/src/conductor.ts:645

removeListener

removeListener<T>(event: T, fn?: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void), context?: any, once?: boolean): Conductor
Remove the listeners of a given event.
Type Parameters
- T extends keyof ConductorEvents
Parameters
- event: T
- Optional fn: ((...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]) => void)
  - - (...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]): void
    - Parameters
      
      Rest ...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]
      
      Returns void
- Optional context: any
- Optional once: boolean
Returns Conductor
Inherited from EventEmitter.removeListener
- Defined in node_modules/eventemitter3/index.d.ts:63

resetResolver

resetResolver(): void
Resets the resolve-time, so that the resolving will happen for the point-in time NOW next time

Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:679

setDatastore

setDatastore(newStore: Datastore): void
Parameters
- newStore: Datastore
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:1157

setTimelineAndMappings

setTimelineAndMappings(timeline: TSRTimeline, mappings?: Mappings<unknown>): void
Sets a new timeline and resets the resolver.
Parameters
- timeline: TSRTimeline
- Optional mappings: Mappings<unknown>
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:312

`Private` statReport

statReport(startTime: number, report: StatReport): void
Parameters
- startTime: number
- report: StatReport
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:1427

`Private` statStartMeasure

statStartMeasure(reason: string): void
Parameters
- reason: string
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:1418

`Private` terminateUnwantedDevice

terminateUnwantedDevice(newDevice: undefined | BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>): Promise<void>
Parameters
- newDevice: undefined | BaseRemoteDeviceIntegration<DeviceOptionsBase<any>>
Returns Promise<void>
- Defined in packages/timeline-state-resolver/src/conductor.ts:593

`Private` throwIfAborted

throwIfAborted(signal: undefined | AbortSignal, deviceId: string, action: string): void
Parameters
- signal: undefined | AbortSignal
- deviceId: string
- action: string
Returns void
- Defined in packages/timeline-state-resolver/src/conductor.ts:499

`Static` calculateResolveTime

calculateResolveTime(timelineSize: number, multiplier: number): number
Calculates the estimated time it'll take to resolve a timeline of a certain size
Parameters
- timelineSize: number
- multiplier: number
Returns number
- Defined in packages/timeline-state-resolver/src/conductor.ts:1234

Class Conductor

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

options: ConductorOptions = {}

Returns Conductor

Properties

Private _actionQueue

Private _callbackInstances

Private _datastore

Private _deviceStates

Type declaration

[deviceId: string]: DeviceState[]

Private _doOnTime

Private _estimateResolveTimeMultiplier

Private Optional _getCurrentTime

Type declaration

Returns number

Private _interval

Private _isInitialized

Private _logDebug

Private _mappings

Private _multiThreadedResolver

Private _nextResolveTime

Private _options

Private _resolveTimelineTrigger

Private _resolved

Type declaration

resolveTime: number

resolvedTimeline: null | ResolvedTimeline<TSRTimelineContent>

validTo: number

Private _resolver

Private _sentCallbacks

Private _statMeasureReason

Private _statMeasureStart

Private _statReports

Private _timeline

Private _timelineHash

Private _timelineSize

Private _triggerSendStartStopCallbacksTimeout

Private _useCacheWhenResolving

Private activationId

Private devices

Accessors

estimateResolveTimeMultiplier

Returns number

Parameters

value: number

Returns void

logDebug

Returns boolean

Parameters

val: boolean

Returns void

mapping

Returns Mappings<unknown>

timeline

Returns TSRTimeline

timelineHash

Returns undefined | string

Parameters

hash: undefined | string

Returns void

Methods

Private _diffStateForCallbacks

Parameters

activeObjects: TimelineCallbacks

tlTime: number

Returns void

Private _mapAllDevices

Type Parameters

T

Parameters

includeUninitialized: boolean

`Private` _actionQueue

`Private` _callbackInstances

`Private` _datastore

`Private` _deviceStates

`Private` _doOnTime

`Private` _estimateResolveTimeMultiplier

`Private` `Optional` _getCurrentTime

`Private` _interval

`Private` _isInitialized

`Private` _logDebug

`Private` _mappings

`Private` _multiThreadedResolver

`Private` _nextResolveTime

`Private` _options

`Private` _resolveTimelineTrigger

`Private` _resolved

`Private` _resolver

`Private` _sentCallbacks

`Private` _statMeasureReason

`Private` _statMeasureStart

`Private` _statReports

`Private` _timeline

`Private` _timelineHash

`Private` _timelineSize

`Private` _triggerSendStartStopCallbacksTimeout

`Private` _useCacheWhenResolving

`Private` activationId

`Private` devices

`Private` _diffStateForCallbacks

`Private` _mapAllDevices

`Private` _queueCallback

`Private` _resolveTimeline

`Private` _resolveTimelineInner

`Private` _sendStartStopCallbacks

`Private` _setDeviceState

`Private` _triggerResolveTimeline

`Optional` timeUntilTrigger: number

`Private` _triggerSendStartStopCallbacks

`Optional` activeRundownPlaylistId: string

`Rest` ...args: ArgumentMap<ConductorEvents>[Extract<T, keyof ConductorEvents>]

`Optional` context: any

`Optional` options: {
signal?: AbortSignal;
}

`Optional` signal?: AbortSignal

`Private` createDeviceContainer

`Optional` okToDestroyStuff: boolean

`Optional` activationId: string