From 28eda023d2bc508e2ae8b1286e02f745749dbf30 Mon Sep 17 00:00:00 2001 From: Even Rognlien Date: Mon, 26 Jun 2023 22:36:16 +0200 Subject: [PATCH 01/12] Start working on a simplified API layer --- samples/typescript/apiHelper.ts | 66 +++++++ src/helper/ApiHelper.ts | 14 ++ src/helper/SimulationVariablesHelper.ts | 248 ++++++++++++++++++++++++ src/helper/SystemEventsHelper.ts | 59 ++++++ 4 files changed, 387 insertions(+) create mode 100644 samples/typescript/apiHelper.ts create mode 100644 src/helper/ApiHelper.ts create mode 100644 src/helper/SimulationVariablesHelper.ts create mode 100644 src/helper/SystemEventsHelper.ts diff --git a/samples/typescript/apiHelper.ts b/samples/typescript/apiHelper.ts new file mode 100644 index 0000000..4bed014 --- /dev/null +++ b/samples/typescript/apiHelper.ts @@ -0,0 +1,66 @@ +import { ApiHelper } from '../../dist/helper/ApiHelper'; +import { open, Protocol, SimConnectDataType } from '../../dist'; + +open('Testing', Protocol.KittyHawk, { host: '192.168.0.21', port: 1337 }) + .then(async ({ recvOpen, handle }) => { + console.log('Yay, connected', recvOpen); + handle.on('exception', ex => console.log(ex)); + + const api = new ApiHelper(handle); + + api.systemEvents.addEventListener('Pause', data => { + console.log(data === 0 ? 'UnPaused' : 'Paused'); + }); + + const pos = await api.simulationVariables.readValues({ + cat: { + simulationVariable: 'CATEGORY', + units: null, + dataType: SimConnectDataType.STRINGV, + }, + fuel: { + simulationVariable: 'FUEL TOTAL QUANTITY', + units: 'liters', + dataType: SimConnectDataType.INT32, + }, + aircraft: { + simulationVariable: 'TITLE', + units: null, + dataType: SimConnectDataType.STRINGV, + }, + }); + + api.simulationVariables.monitorValues( + { + lat: { + simulationVariable: 'PLANE LATITUDE', + units: 'degrees', + dataType: SimConnectDataType.FLOAT64, + }, + lng: { + simulationVariable: 'PLANE LONGITUDE', + units: 'degrees', + dataType: SimConnectDataType.FLOAT64, + }, + cat: { + simulationVariable: 'TITLE', + units: null, + dataType: SimConnectDataType.STRING128, + }, + ias: { + simulationVariable: 'AIRSPEED INDICATED', + units: 'knots', + dataType: SimConnectDataType.INT32, + }, + }, + data => { + console.log('Some of this data changed:', data); + }, + { onlyOnChange: true } + ); + + console.log(pos); + }) + .catch(e => { + console.log('Failed to connect', e); + }); diff --git a/src/helper/ApiHelper.ts b/src/helper/ApiHelper.ts new file mode 100644 index 0000000..c9a510e --- /dev/null +++ b/src/helper/ApiHelper.ts @@ -0,0 +1,14 @@ +import { SimConnectConnection } from '../SimConnectConnection'; +import { SimulationVariablesHelper } from './SimulationVariablesHelper'; +import { SystemEventsHelper } from './SystemEventsHelper'; + +export class ApiHelper { + simulationVariables: SimulationVariablesHelper; + + systemEvents: SystemEventsHelper; + + constructor(handle: SimConnectConnection) { + this.simulationVariables = new SimulationVariablesHelper(handle); + this.systemEvents = new SystemEventsHelper(handle); + } +} diff --git a/src/helper/SimulationVariablesHelper.ts b/src/helper/SimulationVariablesHelper.ts new file mode 100644 index 0000000..78b995b --- /dev/null +++ b/src/helper/SimulationVariablesHelper.ts @@ -0,0 +1,248 @@ +import { SimConnectConstants } from '../SimConnectConstants'; +import { SimConnectDataType } from '../enums/SimConnectDataType'; +import { SimConnectPeriod } from '../enums/SimConnectPeriod'; +import { DataRequestFlag } from '../flags/DataRequestFlag'; +import { SimConnectConnection } from '../SimConnectConnection'; +import { RawBuffer } from '../RawBuffer'; +import { + InitPosition, + LatLonAlt, + MarkerState, + readInitPosition, + readLatLonAlt, + readMarkerState, + readWaypoint, + readXYZ, + Waypoint, + XYZ, +} from '../dto'; + +class SimulationVariablesHelper { + private _handle: SimConnectConnection; + + private _nextDataDefinitionId: number; + + private _nextDataRequestId: number; + + constructor(handle: SimConnectConnection) { + this._handle = handle; + this._nextDataDefinitionId = 0; + this._nextDataRequestId = 0; + } + + /** + * Read a single simulation variable + * TODO: perhaps this is not really needed? + */ + async readValue( + simulationVariable: string, + units: string | null, + dataType: SimConnectDataType, + simObjectId: number = SimConnectConstants.OBJECT_ID_USER, + epsilon?: number + ): Promise { + const values = await this.readValues( + { value: { simulationVariable, units, dataType, simObjectId, epsilon } }, + simObjectId + ); + return values.value as OutputVariableType[T]; + } + + /** + * Read a set of simulation variables once + * @param requestStructure + * @param simObjectId + */ + async readValues( + requestStructure: T, + simObjectId: number = SimConnectConstants.OBJECT_ID_USER + ): Promise> { + const sub = this.makeSubscription({ + requestStructure, + simObjectId, + period: SimConnectPeriod.ONCE, + }); + + return new Promise(resolve => { + this._handle.once('simObjectData', recvSimObjectData => { + if ( + sub.requestId === recvSimObjectData.requestID && + sub.defineId === recvSimObjectData.defineID + ) { + resolve( + extractDataStructureFromBuffer(requestStructure, recvSimObjectData.data) + ); + } + }); + }); + } + + /** + * Continuously read a set of simulation variables + * @param simulationVariables + * @param callback + * @param options + */ + monitorValues( + simulationVariables: T, + callback: (values: VariablesResponse) => void, + options?: { + onlyOnChange?: boolean; + simObjectId?: number; + interval?: SimConnectPeriod; + } + ) { + const sub = this.makeSubscription({ + requestStructure: simulationVariables, + simObjectId: options?.simObjectId || SimConnectConstants.OBJECT_ID_USER, + period: options?.interval || SimConnectPeriod.SIM_FRAME, + flags: options?.onlyOnChange ? DataRequestFlag.DATA_REQUEST_FLAG_CHANGED : 0, + }); + + this._handle.on('simObjectData', recvSimObjectData => { + if ( + sub.requestId === recvSimObjectData.requestID && + sub.defineId === recvSimObjectData.defineID + ) { + callback( + extractDataStructureFromBuffer(simulationVariables, recvSimObjectData.data) + ); + } + }); + } + + private makeSubscription(params: { + requestStructure: T; + period: SimConnectPeriod; + simObjectId: number; + flags?: number; + }): { defineId: number; requestId: number } { + const requestId = this._nextDataRequestId++; + const defineId = this._nextDataDefinitionId++; + + Object.values(params.requestStructure) + .reverse() + .forEach(requestedValue => { + this._handle.addToDataDefinition( + defineId, + requestedValue.simulationVariable, + requestedValue.units, + requestedValue.dataType, + requestedValue.epsilon + ); + }); + + this._handle.requestDataOnSimObject( + requestId, + defineId, + params.simObjectId, + params.period, + DataRequestFlag.DATA_REQUEST_FLAG_DEFAULT | (params.flags || 0) + ); + + return { requestId, defineId }; + } +} + +function extractDataStructureFromBuffer( + requestStructure: T, + rawBuffer: RawBuffer +) { + return Object.keys(requestStructure) + .reverse() // Reverse to get the same order as requested order + .reduce((result, propName) => { + return { + [propName]: extractSimConnectValue(rawBuffer, requestStructure[propName].dataType), + ...result, + }; + return result; + }, {} as VariablesResponse); +} + +function extractSimConnectValue( + rawBuffer: RawBuffer, + dataType: T +): OutputVariableType[T] { + switch (dataType) { + case SimConnectDataType.INVALID: + return undefined as OutputVariableType[T]; + case SimConnectDataType.INT32: + return rawBuffer.readInt32() as OutputVariableType[T]; + case SimConnectDataType.INT64: + return rawBuffer.readInt64() as OutputVariableType[T]; + case SimConnectDataType.FLOAT32: + return rawBuffer.readFloat32() as OutputVariableType[T]; + case SimConnectDataType.FLOAT64: + return rawBuffer.readFloat64() as OutputVariableType[T]; + case SimConnectDataType.STRING8: + return rawBuffer.readString8() as OutputVariableType[T]; + case SimConnectDataType.STRING32: + return rawBuffer.readString32() as OutputVariableType[T]; + case SimConnectDataType.STRING64: + return rawBuffer.readString64() as OutputVariableType[T]; + case SimConnectDataType.STRING128: + return rawBuffer.readString128() as OutputVariableType[T]; + case SimConnectDataType.STRING256: + return rawBuffer.readString256() as OutputVariableType[T]; + case SimConnectDataType.STRING260: + return rawBuffer.readString260() as OutputVariableType[T]; + case SimConnectDataType.STRINGV: + return rawBuffer.readStringV() as OutputVariableType[T]; + case SimConnectDataType.INITPOSITION: + return readInitPosition(rawBuffer) as OutputVariableType[T]; + case SimConnectDataType.MARKERSTATE: + return readMarkerState(rawBuffer) as OutputVariableType[T]; + case SimConnectDataType.WAYPOINT: + return readWaypoint(rawBuffer) as OutputVariableType[T]; + case SimConnectDataType.LATLONALT: + return readLatLonAlt(rawBuffer) as OutputVariableType[T]; + case SimConnectDataType.XYZ: + return readXYZ(rawBuffer) as OutputVariableType[T]; + case SimConnectDataType.MAX: + return undefined as OutputVariableType[T]; + default: + return undefined as OutputVariableType[T]; + } +} + +// Types: + +type VariableRequestDefinition = { + simulationVariable: string; + units: string | null; + dataType: SimConnectDataType; + epsilon?: number | undefined; +}; + +type RequestedVariables = { + [propName: string]: VariableRequestDefinition; +}; + +type VariablesResponse = { + [K in keyof R]: OutputVariableType[R[K]['dataType']]; +}; + +type OutputVariableType = { + [T in SimConnectDataType]: { + [SimConnectDataType.INVALID]: undefined; + [SimConnectDataType.INT32]: number; + [SimConnectDataType.INT64]: number; + [SimConnectDataType.FLOAT32]: number; + [SimConnectDataType.FLOAT64]: number; + [SimConnectDataType.STRING8]: string; + [SimConnectDataType.STRING32]: string; + [SimConnectDataType.STRING64]: string; + [SimConnectDataType.STRING128]: string; + [SimConnectDataType.STRING256]: string; + [SimConnectDataType.STRING260]: string; + [SimConnectDataType.STRINGV]: string; + [SimConnectDataType.INITPOSITION]: InitPosition; + [SimConnectDataType.MARKERSTATE]: MarkerState; + [SimConnectDataType.WAYPOINT]: Waypoint; + [SimConnectDataType.LATLONALT]: LatLonAlt; + [SimConnectDataType.XYZ]: XYZ; + [SimConnectDataType.MAX]: undefined; + }[T]; +}; + +export { SimulationVariablesHelper }; diff --git a/src/helper/SystemEventsHelper.ts b/src/helper/SystemEventsHelper.ts new file mode 100644 index 0000000..0e4298a --- /dev/null +++ b/src/helper/SystemEventsHelper.ts @@ -0,0 +1,59 @@ +import { SimConnectConnection } from '../SimConnectConnection'; + +export class SystemEventsHelper { + _nextClientEventId; + + _handle: SimConnectConnection; + + _subscriptions: { [systemEventName: string]: EventSubscription }; + + constructor(handle: SimConnectConnection) { + this._handle = handle; + this._nextClientEventId = 0; + this._subscriptions = {}; + + handle.on('event', event => { + Object.values(this._subscriptions).forEach(subscription => { + if (event.clientEventId === subscription.clientEventId) { + subscription.eventHandlers.forEach(eventHandler => { + eventHandler(event.data); + }); + } + }); + }); + } + + addEventListener(systemEventName: string, eventHandler: SystemEventHandler) { + const existingSub = this._subscriptions[systemEventName]; + if (existingSub) { + existingSub.eventHandlers.push(eventHandler); + } else { + this._subscriptions[systemEventName] = { + clientEventId: this._nextClientEventId, + eventHandlers: [eventHandler], + }; + this._handle.subscribeToSystemEvent(this._nextClientEventId, systemEventName); + this._nextClientEventId++; + } + } + + removeEventListener(systemEventName: string, eventHandler?: SystemEventHandler) { + const sub = this._subscriptions[systemEventName]; + if (!sub) { + throw Error(`No subscriptions exists for ${systemEventName}`); + } + + sub.eventHandlers = eventHandler ? sub.eventHandlers.filter(cb => eventHandler !== cb) : []; + if (sub.eventHandlers.length === 0) { + this._handle.unsubscribeFromSystemEvent(sub.clientEventId); + delete this._subscriptions[systemEventName]; + } + } +} + +type SystemEventHandler = (data: number) => void; + +type EventSubscription = { + clientEventId: number; + eventHandlers: SystemEventHandler[]; +}; From cba3198fe3f3f572be6f1a492a6738d3bd7d0009 Mon Sep 17 00:00:00 2001 From: EvenAR Date: Wed, 28 Jun 2023 22:09:52 +0200 Subject: [PATCH 02/12] Start on exception handling for ApiHelper --- samples/typescript/apiHelper.ts | 28 +++-- src/helper/SimulationVariablesHelper.ts | 136 ++++++++++++++++++------ 2 files changed, 113 insertions(+), 51 deletions(-) diff --git a/samples/typescript/apiHelper.ts b/samples/typescript/apiHelper.ts index 4bed014..b9edbbe 100644 --- a/samples/typescript/apiHelper.ts +++ b/samples/typescript/apiHelper.ts @@ -1,36 +1,33 @@ import { ApiHelper } from '../../dist/helper/ApiHelper'; -import { open, Protocol, SimConnectDataType } from '../../dist'; +import { open, Protocol, SimConnectDataType, SimObjectType } from '../../dist'; open('Testing', Protocol.KittyHawk, { host: '192.168.0.21', port: 1337 }) .then(async ({ recvOpen, handle }) => { console.log('Yay, connected', recvOpen); handle.on('exception', ex => console.log(ex)); - const api = new ApiHelper(handle); + const { systemEvents, simulationVariables } = new ApiHelper(handle); - api.systemEvents.addEventListener('Pause', data => { + systemEvents.addEventListener('Pause', data => { console.log(data === 0 ? 'UnPaused' : 'Paused'); }); - const pos = await api.simulationVariables.readValues({ + const pos = await simulationVariables.readValues({ cat: { simulationVariable: 'CATEGORY', units: null, dataType: SimConnectDataType.STRINGV, }, - fuel: { - simulationVariable: 'FUEL TOTAL QUANTITY', + fuel3: { + simulationVariable: 'FUEL TOTAL QUANTItTY', units: 'liters', dataType: SimConnectDataType.INT32, }, - aircraft: { - simulationVariable: 'TITLE', - units: null, - dataType: SimConnectDataType.STRINGV, - }, }); - api.simulationVariables.monitorValues( + simulationVariables.monitorSimulationObjects( + SimObjectType.AIRCRAFT, + 10000, { lat: { simulationVariable: 'PLANE LATITUDE', @@ -53,10 +50,9 @@ open('Testing', Protocol.KittyHawk, { host: '192.168.0.21', port: 1337 }) dataType: SimConnectDataType.INT32, }, }, - data => { - console.log('Some of this data changed:', data); - }, - { onlyOnChange: true } + values => { + console.log('nearby aircraft', values); + } ); console.log(pos); diff --git a/src/helper/SimulationVariablesHelper.ts b/src/helper/SimulationVariablesHelper.ts index 78b995b..ef212df 100644 --- a/src/helper/SimulationVariablesHelper.ts +++ b/src/helper/SimulationVariablesHelper.ts @@ -16,6 +16,8 @@ import { Waypoint, XYZ, } from '../dto'; +import { SimObjectType } from '../enums/SimObjectType'; +import { RecvException } from '../recv'; class SimulationVariablesHelper { private _handle: SimConnectConnection; @@ -30,24 +32,6 @@ class SimulationVariablesHelper { this._nextDataRequestId = 0; } - /** - * Read a single simulation variable - * TODO: perhaps this is not really needed? - */ - async readValue( - simulationVariable: string, - units: string | null, - dataType: SimConnectDataType, - simObjectId: number = SimConnectConstants.OBJECT_ID_USER, - epsilon?: number - ): Promise { - const values = await this.readValues( - { value: { simulationVariable, units, dataType, simObjectId, epsilon } }, - simObjectId - ); - return values.value as OutputVariableType[T]; - } - /** * Read a set of simulation variables once * @param requestStructure @@ -57,7 +41,7 @@ class SimulationVariablesHelper { requestStructure: T, simObjectId: number = SimConnectConstants.OBJECT_ID_USER ): Promise> { - const sub = this.makeSubscription({ + const sub = this._makeSubscription({ requestStructure, simObjectId, period: SimConnectPeriod.ONCE, @@ -82,6 +66,9 @@ class SimulationVariablesHelper { * @param simulationVariables * @param callback * @param options + * @param options.onlyOnChange If the callback should trigger only when one of the variables change + * @param options.simObjectId Defaults to the user's aircraft + * @param {SimConnectPeriod} options.interval */ monitorValues( simulationVariables: T, @@ -92,7 +79,7 @@ class SimulationVariablesHelper { interval?: SimConnectPeriod; } ) { - const sub = this.makeSubscription({ + const sub = this._makeSubscription({ requestStructure: simulationVariables, simObjectId: options?.simObjectId || SimConnectConstants.OBJECT_ID_USER, period: options?.interval || SimConnectPeriod.SIM_FRAME, @@ -111,28 +98,40 @@ class SimulationVariablesHelper { }); } - private makeSubscription(params: { + monitorSimulationObjects( + type: SimObjectType, + radiusMeters: number, + simulationVariables: T, + callback: (values: VariablesResponse) => void + ) { + const sub = this._makeSubscriptionByType({ + requestStructure: simulationVariables, + radiusMeters, + type, + }); + + this._handle.on('simObjectDataByType', recvSimObjectData => { + if ( + sub.requestId === recvSimObjectData.requestID && + sub.defineId === recvSimObjectData.defineID + ) { + callback( + extractDataStructureFromBuffer(simulationVariables, recvSimObjectData.data) + ); + } + }); + } + + private _makeSubscription(params: { requestStructure: T; period: SimConnectPeriod; simObjectId: number; flags?: number; }): { defineId: number; requestId: number } { + const defineId = this._defineData(params.requestStructure); const requestId = this._nextDataRequestId++; - const defineId = this._nextDataDefinitionId++; - - Object.values(params.requestStructure) - .reverse() - .forEach(requestedValue => { - this._handle.addToDataDefinition( - defineId, - requestedValue.simulationVariable, - requestedValue.units, - requestedValue.dataType, - requestedValue.epsilon - ); - }); - this._handle.requestDataOnSimObject( + const sendId = this._handle.requestDataOnSimObject( requestId, defineId, params.simObjectId, @@ -140,8 +139,75 @@ class SimulationVariablesHelper { DataRequestFlag.DATA_REQUEST_FLAG_DEFAULT | (params.flags || 0) ); + this._checkForExceptions(sendId, 'Failed to subscribe'); + return { requestId, defineId }; } + + private _makeSubscriptionByType(params: { + requestStructure: T; + radiusMeters: number; + type: SimObjectType; + }): { defineId: number; requestId: number } { + const requestId = this._nextDataRequestId++; + + const defineId = this._defineData(params.requestStructure); + + const sendId = this._handle.requestDataOnSimObjectType( + requestId, + defineId, + params.radiusMeters, + params.type + ); + + this._checkForExceptions(sendId, 'Failed to subscribe'); + + return { requestId, defineId }; + } + + private _defineData(requestStructure: T): number { + const defineId = this._nextDataDefinitionId++; + + /** + * We register the simulation variables in reverse order, so we receive them in the + * same order that they were defined in the requestStructure (because that looks professional). + */ + const userDefinedNames = Object.keys(requestStructure).reverse(); + const variableDefinitions = Object.values(requestStructure).reverse(); + + variableDefinitions.forEach((requestedValue, index) => { + const sendId = this._handle.addToDataDefinition( + defineId, + requestedValue.simulationVariable, + requestedValue.units, + requestedValue.dataType, + requestedValue.epsilon + ); + this._checkForExceptions( + sendId, + `Failed to register simulation variable '${userDefinedNames[index]}'` + ); + }); + + return defineId; + } + + private _checkForExceptions(sendId: number, message: string) { + function exceptionHandler(recvException: RecvException) { + if (recvException.sendId === sendId) { + throw Error( + `SimConnectException - sendId=${recvException.sendId}, exception=${recvException.exception}, message="${message}"` + ); + } + } + + this._handle.on('exception', exceptionHandler); + + // Give SimConnect server some time to throw the exception, then remove the listener + setTimeout(() => { + this._handle.off('exception', exceptionHandler); + }, 1000); + } } function extractDataStructureFromBuffer( From 60eb01272883707c2e7e6b854a917584aa5f2637 Mon Sep 17 00:00:00 2001 From: EvenAR Date: Sun, 2 Jul 2023 16:09:53 +0200 Subject: [PATCH 03/12] Add better error handling to api-helper --- samples/typescript/apiHelper.ts | 103 +++++++++-------- .../SimulationVariablesHelper.ts | 105 +++++++++++------- .../SystemEventsHelper.ts | 16 ++- .../ApiHelper.ts => ApiHelper/index.ts} | 0 src/ApiHelper/utils.ts | 22 ++++ 5 files changed, 156 insertions(+), 90 deletions(-) rename src/{helper => ApiHelper}/SimulationVariablesHelper.ts (81%) rename src/{helper => ApiHelper}/SystemEventsHelper.ts (71%) rename src/{helper/ApiHelper.ts => ApiHelper/index.ts} (100%) create mode 100644 src/ApiHelper/utils.ts diff --git a/samples/typescript/apiHelper.ts b/samples/typescript/apiHelper.ts index b9edbbe..a8ba337 100644 --- a/samples/typescript/apiHelper.ts +++ b/samples/typescript/apiHelper.ts @@ -1,62 +1,71 @@ -import { ApiHelper } from '../../dist/helper/ApiHelper'; -import { open, Protocol, SimConnectDataType, SimObjectType } from '../../dist'; +import { ApiHelper } from '../../dist/apiHelper'; +import { open, Protocol, SimConnectDataType } from '../../dist'; -open('Testing', Protocol.KittyHawk, { host: '192.168.0.21', port: 1337 }) +open('API-helper example', Protocol.KittyHawk, { host: '192.168.0.21', port: 1337 }) .then(async ({ recvOpen, handle }) => { - console.log('Yay, connected', recvOpen); - handle.on('exception', ex => console.log(ex)); + console.log('Yay, connected!', recvOpen); + await doStuff(new ApiHelper(handle)); + }) + .catch(e => { + console.log('Unhandled error', e); + }); - const { systemEvents, simulationVariables } = new ApiHelper(handle); +async function doStuff(apiHelper: ApiHelper) { + const { systemEvents, simulationVariables } = apiHelper; - systemEvents.addEventListener('Pause', data => { - console.log(data === 0 ? 'UnPaused' : 'Paused'); - }); + /** Subscribe to a system event */ + systemEvents.addEventListener('Pause', data => { + console.log(data === 0 ? 'UnPaused' : 'Paused'); + }); - const pos = await simulationVariables.readValues({ + /** Get a set of simulation variables once */ + simulationVariables + .readValues({ + acTitle: { + simulationVariable: 'TITLE', + units: null, + dataType: SimConnectDataType.STRING128, + }, cat: { simulationVariable: 'CATEGORY', units: null, - dataType: SimConnectDataType.STRINGV, + dataType: SimConnectDataType.STRING128, }, - fuel3: { - simulationVariable: 'FUEL TOTAL QUANTItTY', + fuelOnBoard: { + simulationVariable: 'FUEL TOTA L QUANTITY', units: 'liters', dataType: SimConnectDataType.INT32, }, - }); + }) + .then(data => { + console.log( + `Current aircraft is '${data.acTitle}'. It has ${data.fuelOnBoard} liters of fuel on board` + ); + }) + .catch(err => console.log(err)); - simulationVariables.monitorSimulationObjects( - SimObjectType.AIRCRAFT, - 10000, - { - lat: { - simulationVariable: 'PLANE LATITUDE', - units: 'degrees', - dataType: SimConnectDataType.FLOAT64, - }, - lng: { - simulationVariable: 'PLANE LONGITUDE', - units: 'degrees', - dataType: SimConnectDataType.FLOAT64, - }, - cat: { - simulationVariable: 'TITLE', - units: null, - dataType: SimConnectDataType.STRING128, - }, - ias: { - simulationVariable: 'AIRSPEED INDICATED', - units: 'knots', - dataType: SimConnectDataType.INT32, - }, + /** Get simulation variables whenever they changes */ + simulationVariables.monitorValues( + { + airspeed: { + simulationVariable: 'AIRSPEED INDICATED', + units: 'knots', + dataType: SimConnectDataType.INT32, }, - values => { - console.log('nearby aircraft', values); + position: { + simulationVariable: 'STRUCT LATLONALT', + units: null, + dataType: SimConnectDataType.LATLONALT, + }, + }, + (err, data) => { + if (err) { + console.log(err); + } else if (data) { + console.log('Airspeed:', data.airspeed); + console.log('Position:', data.position); } - ); - - console.log(pos); - }) - .catch(e => { - console.log('Failed to connect', e); - }); + }, + { onlyOnChange: true } + ); +} diff --git a/src/helper/SimulationVariablesHelper.ts b/src/ApiHelper/SimulationVariablesHelper.ts similarity index 81% rename from src/helper/SimulationVariablesHelper.ts rename to src/ApiHelper/SimulationVariablesHelper.ts index ef212df..6ce2680 100644 --- a/src/helper/SimulationVariablesHelper.ts +++ b/src/ApiHelper/SimulationVariablesHelper.ts @@ -17,7 +17,17 @@ import { XYZ, } from '../dto'; import { SimObjectType } from '../enums/SimObjectType'; -import { RecvException } from '../recv'; +import { checkForExceptions } from './utils'; + +export type SimvarCallback = ( + err: SimConnectError | null, + data: VariablesResponse | null +) => void; + +export type SimConnectError = { + message: string; + exception: string; +}; class SimulationVariablesHelper { private _handle: SimConnectConnection; @@ -41,15 +51,20 @@ class SimulationVariablesHelper { requestStructure: T, simObjectId: number = SimConnectConstants.OBJECT_ID_USER ): Promise> { - const sub = this._makeSubscription({ - requestStructure, - simObjectId, - period: SimConnectPeriod.ONCE, - }); - - return new Promise(resolve => { + return new Promise((resolve, reject) => { + let hasFailed = false; + const sub = this._makeSubscription({ + requestStructure, + simObjectId, + period: SimConnectPeriod.ONCE, + errorHandler: error => { + hasFailed = true; + reject(error); + }, + }); this._handle.once('simObjectData', recvSimObjectData => { if ( + !hasFailed && sub.requestId === recvSimObjectData.requestID && sub.defineId === recvSimObjectData.defineID ) { @@ -72,26 +87,33 @@ class SimulationVariablesHelper { */ monitorValues( simulationVariables: T, - callback: (values: VariablesResponse) => void, + callback: SimvarCallback, options?: { onlyOnChange?: boolean; simObjectId?: number; interval?: SimConnectPeriod; } ) { + let hasFailed = false; const sub = this._makeSubscription({ requestStructure: simulationVariables, simObjectId: options?.simObjectId || SimConnectConstants.OBJECT_ID_USER, period: options?.interval || SimConnectPeriod.SIM_FRAME, flags: options?.onlyOnChange ? DataRequestFlag.DATA_REQUEST_FLAG_CHANGED : 0, + errorHandler: err => { + hasFailed = true; + callback(err, null); + }, }); this._handle.on('simObjectData', recvSimObjectData => { if ( + !hasFailed && sub.requestId === recvSimObjectData.requestID && sub.defineId === recvSimObjectData.defineID ) { callback( + null, extractDataStructureFromBuffer(simulationVariables, recvSimObjectData.data) ); } @@ -102,12 +124,13 @@ class SimulationVariablesHelper { type: SimObjectType, radiusMeters: number, simulationVariables: T, - callback: (values: VariablesResponse) => void + callback: SimvarCallback ) { const sub = this._makeSubscriptionByType({ requestStructure: simulationVariables, radiusMeters, type, + errorHandler: err => callback(err, null), }); this._handle.on('simObjectDataByType', recvSimObjectData => { @@ -116,6 +139,7 @@ class SimulationVariablesHelper { sub.defineId === recvSimObjectData.defineID ) { callback( + null, extractDataStructureFromBuffer(simulationVariables, recvSimObjectData.data) ); } @@ -127,8 +151,9 @@ class SimulationVariablesHelper { period: SimConnectPeriod; simObjectId: number; flags?: number; + errorHandler: (error: SimConnectError) => void; }): { defineId: number; requestId: number } { - const defineId = this._defineData(params.requestStructure); + const defineId = this._defineData(params.requestStructure, params.errorHandler); const requestId = this._nextDataRequestId++; const sendId = this._handle.requestDataOnSimObject( @@ -139,7 +164,12 @@ class SimulationVariablesHelper { DataRequestFlag.DATA_REQUEST_FLAG_DEFAULT | (params.flags || 0) ); - this._checkForExceptions(sendId, 'Failed to subscribe'); + checkForExceptions(this._handle, sendId, ex => + params.errorHandler({ + message: 'Failed to request data for sim object', + exception: ex, + }) + ); return { requestId, defineId }; } @@ -148,10 +178,11 @@ class SimulationVariablesHelper { requestStructure: T; radiusMeters: number; type: SimObjectType; + errorHandler: (error: SimConnectError) => void; }): { defineId: number; requestId: number } { const requestId = this._nextDataRequestId++; - const defineId = this._defineData(params.requestStructure); + const defineId = this._defineData(params.requestStructure, params.errorHandler); const sendId = this._handle.requestDataOnSimObjectType( requestId, @@ -160,12 +191,20 @@ class SimulationVariablesHelper { params.type ); - this._checkForExceptions(sendId, 'Failed to subscribe'); + checkForExceptions(this._handle, sendId, ex => + params.errorHandler({ + message: 'Failed to request data for sim object type', + exception: ex, + }) + ); return { requestId, defineId }; } - private _defineData(requestStructure: T): number { + private _defineData( + requestStructure: T, + errorHandler: (error: SimConnectError) => void + ): number { const defineId = this._nextDataDefinitionId++; /** @@ -183,31 +222,16 @@ class SimulationVariablesHelper { requestedValue.dataType, requestedValue.epsilon ); - this._checkForExceptions( - sendId, - `Failed to register simulation variable '${userDefinedNames[index]}'` + checkForExceptions(this._handle, sendId, ex => + errorHandler({ + message: `Something is wrong with the requested value '${userDefinedNames[index]}'`, + exception: ex, + }) ); }); return defineId; } - - private _checkForExceptions(sendId: number, message: string) { - function exceptionHandler(recvException: RecvException) { - if (recvException.sendId === sendId) { - throw Error( - `SimConnectException - sendId=${recvException.sendId}, exception=${recvException.exception}, message="${message}"` - ); - } - } - - this._handle.on('exception', exceptionHandler); - - // Give SimConnect server some time to throw the exception, then remove the listener - setTimeout(() => { - this._handle.off('exception', exceptionHandler); - }, 1000); - } } function extractDataStructureFromBuffer( @@ -216,13 +240,13 @@ function extractDataStructureFromBuffer( ) { return Object.keys(requestStructure) .reverse() // Reverse to get the same order as requested order - .reduce((result, propName) => { - return { + .reduce( + (result, propName) => ({ [propName]: extractSimConnectValue(rawBuffer, requestStructure[propName].dataType), ...result, - }; - return result; - }, {} as VariablesResponse); + }), + {} as VariablesResponse + ); } function extractSimConnectValue( @@ -288,6 +312,7 @@ type VariablesResponse = { [K in keyof R]: OutputVariableType[R[K]['dataType']]; }; +/** Maps the SimConnect data types to JS data types */ type OutputVariableType = { [T in SimConnectDataType]: { [SimConnectDataType.INVALID]: undefined; diff --git a/src/helper/SystemEventsHelper.ts b/src/ApiHelper/SystemEventsHelper.ts similarity index 71% rename from src/helper/SystemEventsHelper.ts rename to src/ApiHelper/SystemEventsHelper.ts index 0e4298a..adaea6b 100644 --- a/src/helper/SystemEventsHelper.ts +++ b/src/ApiHelper/SystemEventsHelper.ts @@ -1,4 +1,5 @@ import { SimConnectConnection } from '../SimConnectConnection'; +import { checkForExceptions } from './utils'; export class SystemEventsHelper { _nextClientEventId; @@ -32,21 +33,30 @@ export class SystemEventsHelper { clientEventId: this._nextClientEventId, eventHandlers: [eventHandler], }; - this._handle.subscribeToSystemEvent(this._nextClientEventId, systemEventName); + const sendId = this._handle.subscribeToSystemEvent( + this._nextClientEventId, + systemEventName + ); this._nextClientEventId++; + checkForExceptions(this._handle, sendId, ex => { + throw Error(`Subscription for system event '${systemEventName}' failed: ${ex}`); + }); } } removeEventListener(systemEventName: string, eventHandler?: SystemEventHandler) { const sub = this._subscriptions[systemEventName]; if (!sub) { - throw Error(`No subscriptions exists for ${systemEventName}`); + throw Error(`No subscription exists for system event '${systemEventName}'`); } sub.eventHandlers = eventHandler ? sub.eventHandlers.filter(cb => eventHandler !== cb) : []; if (sub.eventHandlers.length === 0) { - this._handle.unsubscribeFromSystemEvent(sub.clientEventId); + const sendId = this._handle.unsubscribeFromSystemEvent(sub.clientEventId); delete this._subscriptions[systemEventName]; + checkForExceptions(this._handle, sendId, ex => { + throw Error(`Unsubscription for system event '${systemEventName}' failed: ${ex}`); + }); } } } diff --git a/src/helper/ApiHelper.ts b/src/ApiHelper/index.ts similarity index 100% rename from src/helper/ApiHelper.ts rename to src/ApiHelper/index.ts diff --git a/src/ApiHelper/utils.ts b/src/ApiHelper/utils.ts new file mode 100644 index 0000000..95d5549 --- /dev/null +++ b/src/ApiHelper/utils.ts @@ -0,0 +1,22 @@ +import { RecvException } from '../recv'; +import { SimConnectException } from '../enums/SimConnectException'; +import { SimConnectConnection } from '../SimConnectConnection'; + +export function checkForExceptions( + connection: SimConnectConnection, + sendId: number, + handler: (exception: string) => void +) { + function exceptionHandler(recvException: RecvException) { + if (recvException.sendId === sendId) { + handler(SimConnectException[recvException.exception]); + } + } + + connection.on('exception', exceptionHandler); + + // Give SimConnect server some time to throw the exception, then remove the listener + setTimeout(() => { + connection.off('exception', exceptionHandler); + }, 1000); +} From 421266f822fd56553125e85ed69e7d69a95f6c1d Mon Sep 17 00:00:00 2001 From: EvenAR Date: Sun, 2 Jul 2023 21:32:24 +0200 Subject: [PATCH 04/12] Add helper function for setting/updating simulation variables --- samples/typescript/apiHelper.ts | 46 +++-- src/ApiHelper/BaseHelper.ts | 36 ++++ src/ApiHelper/SimulationVariablesHelper.ts | 224 +++++++++++++++------ src/ApiHelper/SystemEventsHelper.ts | 16 +- src/ApiHelper/utils.ts | 22 -- 5 files changed, 238 insertions(+), 106 deletions(-) create mode 100644 src/ApiHelper/BaseHelper.ts delete mode 100644 src/ApiHelper/utils.ts diff --git a/samples/typescript/apiHelper.ts b/samples/typescript/apiHelper.ts index a8ba337..e52b037 100644 --- a/samples/typescript/apiHelper.ts +++ b/samples/typescript/apiHelper.ts @@ -1,7 +1,7 @@ import { ApiHelper } from '../../dist/apiHelper'; import { open, Protocol, SimConnectDataType } from '../../dist'; -open('API-helper example', Protocol.KittyHawk, { host: '192.168.0.21', port: 1337 }) +open('API-helper example', Protocol.KittyHawk) .then(async ({ recvOpen, handle }) => { console.log('Yay, connected!', recvOpen); await doStuff(new ApiHelper(handle)); @@ -20,40 +20,35 @@ async function doStuff(apiHelper: ApiHelper) { /** Get a set of simulation variables once */ simulationVariables - .readValues({ - acTitle: { - simulationVariable: 'TITLE', + .request({ + TITLE: { units: null, dataType: SimConnectDataType.STRING128, }, - cat: { - simulationVariable: 'CATEGORY', + CATEGORY: { units: null, dataType: SimConnectDataType.STRING128, }, - fuelOnBoard: { - simulationVariable: 'FUEL TOTA L QUANTITY', + 'FUEL TOTAL QUANTITY': { units: 'liters', dataType: SimConnectDataType.INT32, }, }) .then(data => { console.log( - `Current aircraft is '${data.acTitle}'. It has ${data.fuelOnBoard} liters of fuel on board` + `Current aircraft is '${data.TITLE}'. It has ${data['FUEL TOTAL QUANTITY']} liters of fuel on board` ); }) .catch(err => console.log(err)); - /** Get simulation variables whenever they changes */ - simulationVariables.monitorValues( + /** Get simulation variables whenever they change */ + simulationVariables.monitor( { - airspeed: { - simulationVariable: 'AIRSPEED INDICATED', + 'AIRSPEED INDICATED': { units: 'knots', dataType: SimConnectDataType.INT32, }, - position: { - simulationVariable: 'STRUCT LATLONALT', + 'STRUCT LATLONALT': { units: null, dataType: SimConnectDataType.LATLONALT, }, @@ -62,10 +57,27 @@ async function doStuff(apiHelper: ApiHelper) { if (err) { console.log(err); } else if (data) { - console.log('Airspeed:', data.airspeed); - console.log('Position:', data.position); + console.log('Airspeed:', data['AIRSPEED INDICATED']); + console.log('Altitude:', data['STRUCT LATLONALT'].altitude); } }, { onlyOnChange: true } ); + + /** Set throttles to 50% */ + simulationVariables.set( + { + 'GENERAL ENG THROTTLE LEVER POSITION:1': { + value: 50, + units: 'Percent', + dataType: SimConnectDataType.INT32, + }, + 'GENERAL ENG THROTTLE LEVER POSITION:2': { + value: 50, + units: 'Percent', + dataType: SimConnectDataType.INT32, + }, + }, + err => console.log(err) + ); } diff --git a/src/ApiHelper/BaseHelper.ts b/src/ApiHelper/BaseHelper.ts new file mode 100644 index 0000000..5cd8c71 --- /dev/null +++ b/src/ApiHelper/BaseHelper.ts @@ -0,0 +1,36 @@ +import { SimConnectConnection } from '../SimConnectConnection'; +import { SimConnectException } from '../enums/SimConnectException'; + +export class BaseHelper { + protected readonly _handle: SimConnectConnection; + + private _exceptionHandlers: { [sendId: number]: (ex: SimConnectException) => void } = {}; + + constructor(handle: SimConnectConnection) { + this._handle = handle; + + this._handle.on('exception', recvException => { + if (recvException.sendId in this._exceptionHandlers) { + const handler = this._exceptionHandlers[recvException.sendId]; + handler(recvException.exception); + } + }); + } + + /** + * Should be called immediately after sending a simconnect packet + * @param sendId the ID of the newly sent packet + * @param handler function to be called in case of an exception + * @private + */ + protected _checkForException( + sendId: number, + handler: (exception: SimConnectException) => void + ) { + this._exceptionHandlers[sendId] = handler; + setTimeout(() => { + // Give SimConnect server some time to throw the exception, then remove the listener + delete this._exceptionHandlers[sendId]; + }, 1000); + } +} diff --git a/src/ApiHelper/SimulationVariablesHelper.ts b/src/ApiHelper/SimulationVariablesHelper.ts index 6ce2680..f321b11 100644 --- a/src/ApiHelper/SimulationVariablesHelper.ts +++ b/src/ApiHelper/SimulationVariablesHelper.ts @@ -4,6 +4,9 @@ import { SimConnectPeriod } from '../enums/SimConnectPeriod'; import { DataRequestFlag } from '../flags/DataRequestFlag'; import { SimConnectConnection } from '../SimConnectConnection'; import { RawBuffer } from '../RawBuffer'; +import { SimObjectType } from '../enums/SimObjectType'; +import { SimConnectException } from '../enums/SimConnectException'; +import { BaseHelper } from './BaseHelper'; import { InitPosition, LatLonAlt, @@ -16,28 +19,24 @@ import { Waypoint, XYZ, } from '../dto'; -import { SimObjectType } from '../enums/SimObjectType'; -import { checkForExceptions } from './utils'; -export type SimvarCallback = ( +export type SimvarCallback = ( err: SimConnectError | null, data: VariablesResponse | null ) => void; export type SimConnectError = { message: string; - exception: string; + exception: SimConnectException; }; -class SimulationVariablesHelper { - private _handle: SimConnectConnection; - +class SimulationVariablesHelper extends BaseHelper { private _nextDataDefinitionId: number; private _nextDataRequestId: number; constructor(handle: SimConnectConnection) { - this._handle = handle; + super(handle); this._nextDataDefinitionId = 0; this._nextDataRequestId = 0; } @@ -47,7 +46,7 @@ class SimulationVariablesHelper { * @param requestStructure * @param simObjectId */ - async readValues( + async request( requestStructure: T, simObjectId: number = SimConnectConstants.OBJECT_ID_USER ): Promise> { @@ -60,6 +59,7 @@ class SimulationVariablesHelper { errorHandler: error => { hasFailed = true; reject(error); + this._handle.clearDataDefinition(sub.defineId); }, }); this._handle.once('simObjectData', recvSimObjectData => { @@ -71,11 +71,55 @@ class SimulationVariablesHelper { resolve( extractDataStructureFromBuffer(requestStructure, recvSimObjectData.data) ); + this._handle.clearDataDefinition(sub.defineId); } }); }); } + /** + * Updates a set of simulation variables + * @param variablesToSet + * @param errorHandler Called in case of an error + * @param simObjectId + */ + set( + variablesToSet: T, + errorHandler?: (err: SimConnectError) => void, + simObjectId = SimConnectConstants.OBJECT_ID_USER + ) { + const defineId = this._createDataDefinition( + variablesToSet, + error => errorHandler && errorHandler(error) + ); + const rawBuffer = new RawBuffer(0); + + Object.keys(variablesToSet).forEach(name => { + writeSimConnectValue( + rawBuffer, + variablesToSet[name].value, + variablesToSet[name].dataType + ); + }); + + const sendId = this._handle.setDataOnSimObject(defineId, simObjectId, { + buffer: rawBuffer, + arrayCount: 0, + tagged: false, + }); + + this._checkForException(sendId, ex => { + if (errorHandler) { + errorHandler({ + message: `Failed to set data on sim object: ${SimConnectException[ex]}`, + exception: ex, + }); + } + }); + + this._handle.clearDataDefinition(defineId); + } + /** * Continuously read a set of simulation variables * @param simulationVariables @@ -85,7 +129,7 @@ class SimulationVariablesHelper { * @param options.simObjectId Defaults to the user's aircraft * @param {SimConnectPeriod} options.interval */ - monitorValues( + monitor( simulationVariables: T, callback: SimvarCallback, options?: { @@ -103,6 +147,7 @@ class SimulationVariablesHelper { errorHandler: err => { hasFailed = true; callback(err, null); + this._handle.clearDataDefinition(sub.defineId); }, }); @@ -120,7 +165,14 @@ class SimulationVariablesHelper { }); } - monitorSimulationObjects( + /** + * Read simulation variables for a certain object type + * @param type + * @param radiusMeters Radius from user's aircraft + * @param simulationVariables + * @param callback + */ + monitorObjects( type: SimObjectType, radiusMeters: number, simulationVariables: T, @@ -142,18 +194,19 @@ class SimulationVariablesHelper { null, extractDataStructureFromBuffer(simulationVariables, recvSimObjectData.data) ); + // this._handle.clearDataDefinition(sub.defineId); } }); } - private _makeSubscription(params: { + private _makeSubscription(params: { requestStructure: T; period: SimConnectPeriod; simObjectId: number; flags?: number; errorHandler: (error: SimConnectError) => void; }): { defineId: number; requestId: number } { - const defineId = this._defineData(params.requestStructure, params.errorHandler); + const defineId = this._createDataDefinition(params.requestStructure, params.errorHandler); const requestId = this._nextDataRequestId++; const sendId = this._handle.requestDataOnSimObject( @@ -164,9 +217,9 @@ class SimulationVariablesHelper { DataRequestFlag.DATA_REQUEST_FLAG_DEFAULT | (params.flags || 0) ); - checkForExceptions(this._handle, sendId, ex => + this._checkForException(sendId, ex => params.errorHandler({ - message: 'Failed to request data for sim object', + message: `Failed to request data for sim object: ${SimConnectException[ex]}`, exception: ex, }) ); @@ -174,7 +227,7 @@ class SimulationVariablesHelper { return { requestId, defineId }; } - private _makeSubscriptionByType(params: { + private _makeSubscriptionByType(params: { requestStructure: T; radiusMeters: number; type: SimObjectType; @@ -182,7 +235,7 @@ class SimulationVariablesHelper { }): { defineId: number; requestId: number } { const requestId = this._nextDataRequestId++; - const defineId = this._defineData(params.requestStructure, params.errorHandler); + const defineId = this._createDataDefinition(params.requestStructure, params.errorHandler); const sendId = this._handle.requestDataOnSimObjectType( requestId, @@ -191,9 +244,9 @@ class SimulationVariablesHelper { params.type ); - checkForExceptions(this._handle, sendId, ex => + this._checkForException(sendId, ex => params.errorHandler({ - message: 'Failed to request data for sim object type', + message: `Failed to request data for sim object type: ${SimConnectException[ex]}`, exception: ex, }) ); @@ -201,30 +254,30 @@ class SimulationVariablesHelper { return { requestId, defineId }; } - private _defineData( + private _createDataDefinition( requestStructure: T, errorHandler: (error: SimConnectError) => void ): number { const defineId = this._nextDataDefinitionId++; /** - * We register the simulation variables in reverse order, so we receive them in the - * same order that they were defined in the requestStructure (because that looks professional). + * We register the simulation variables in reverse order, so we receive them in the same order + * that they were defined in the requestStructure (because the result looks more professional). */ - const userDefinedNames = Object.keys(requestStructure).reverse(); + const variableNames = Object.keys(requestStructure).reverse(); const variableDefinitions = Object.values(requestStructure).reverse(); variableDefinitions.forEach((requestedValue, index) => { const sendId = this._handle.addToDataDefinition( defineId, - requestedValue.simulationVariable, + variableNames[index], requestedValue.units, requestedValue.dataType, requestedValue.epsilon ); - checkForExceptions(this._handle, sendId, ex => + this._checkForException(sendId, ex => errorHandler({ - message: `Something is wrong with the requested value '${userDefinedNames[index]}'`, + message: `Something is wrong with the definition of '${variableNames[index]}': ${SimConnectException[ex]}`, exception: ex, }) ); @@ -234,86 +287,141 @@ class SimulationVariablesHelper { } } -function extractDataStructureFromBuffer( +function extractDataStructureFromBuffer( requestStructure: T, rawBuffer: RawBuffer ) { return Object.keys(requestStructure) .reverse() // Reverse to get the same order as requested order .reduce( - (result, propName) => ({ - [propName]: extractSimConnectValue(rawBuffer, requestStructure[propName].dataType), + (result, variableName) => ({ + [variableName]: readSimConnectValue( + rawBuffer, + requestStructure[variableName].dataType + ), ...result, }), {} as VariablesResponse ); } -function extractSimConnectValue( +function readSimConnectValue( rawBuffer: RawBuffer, dataType: T -): OutputVariableType[T] { +): JavascriptDataType[T] { switch (dataType) { case SimConnectDataType.INVALID: - return undefined as OutputVariableType[T]; + return undefined as JavascriptDataType[T]; case SimConnectDataType.INT32: - return rawBuffer.readInt32() as OutputVariableType[T]; + return rawBuffer.readInt32() as JavascriptDataType[T]; case SimConnectDataType.INT64: - return rawBuffer.readInt64() as OutputVariableType[T]; + return rawBuffer.readInt64() as JavascriptDataType[T]; case SimConnectDataType.FLOAT32: - return rawBuffer.readFloat32() as OutputVariableType[T]; + return rawBuffer.readFloat32() as JavascriptDataType[T]; case SimConnectDataType.FLOAT64: - return rawBuffer.readFloat64() as OutputVariableType[T]; + return rawBuffer.readFloat64() as JavascriptDataType[T]; case SimConnectDataType.STRING8: - return rawBuffer.readString8() as OutputVariableType[T]; + return rawBuffer.readString8() as JavascriptDataType[T]; case SimConnectDataType.STRING32: - return rawBuffer.readString32() as OutputVariableType[T]; + return rawBuffer.readString32() as JavascriptDataType[T]; case SimConnectDataType.STRING64: - return rawBuffer.readString64() as OutputVariableType[T]; + return rawBuffer.readString64() as JavascriptDataType[T]; case SimConnectDataType.STRING128: - return rawBuffer.readString128() as OutputVariableType[T]; + return rawBuffer.readString128() as JavascriptDataType[T]; case SimConnectDataType.STRING256: - return rawBuffer.readString256() as OutputVariableType[T]; + return rawBuffer.readString256() as JavascriptDataType[T]; case SimConnectDataType.STRING260: - return rawBuffer.readString260() as OutputVariableType[T]; + return rawBuffer.readString260() as JavascriptDataType[T]; case SimConnectDataType.STRINGV: - return rawBuffer.readStringV() as OutputVariableType[T]; + return rawBuffer.readStringV() as JavascriptDataType[T]; case SimConnectDataType.INITPOSITION: - return readInitPosition(rawBuffer) as OutputVariableType[T]; + return readInitPosition(rawBuffer) as JavascriptDataType[T]; case SimConnectDataType.MARKERSTATE: - return readMarkerState(rawBuffer) as OutputVariableType[T]; + return readMarkerState(rawBuffer) as JavascriptDataType[T]; case SimConnectDataType.WAYPOINT: - return readWaypoint(rawBuffer) as OutputVariableType[T]; + return readWaypoint(rawBuffer) as JavascriptDataType[T]; case SimConnectDataType.LATLONALT: - return readLatLonAlt(rawBuffer) as OutputVariableType[T]; + return readLatLonAlt(rawBuffer) as JavascriptDataType[T]; case SimConnectDataType.XYZ: - return readXYZ(rawBuffer) as OutputVariableType[T]; + return readXYZ(rawBuffer) as JavascriptDataType[T]; case SimConnectDataType.MAX: - return undefined as OutputVariableType[T]; + return undefined as JavascriptDataType[T]; default: - return undefined as OutputVariableType[T]; + return undefined as JavascriptDataType[T]; + } +} + +function writeSimConnectValue( + rawBuffer: RawBuffer, + value: JavascriptDataType[T], + dataType: T +) { + switch (dataType) { + case SimConnectDataType.INVALID: + break; + case SimConnectDataType.INT32: + rawBuffer.writeInt32(value as number); + break; + case SimConnectDataType.INT64: + rawBuffer.writeInt64(value as number); + break; + case SimConnectDataType.FLOAT32: + rawBuffer.writeFloat32(value as number); + break; + case SimConnectDataType.FLOAT64: + rawBuffer.writeFloat64(value as number); + break; + case SimConnectDataType.STRING8: + rawBuffer.writeString8(value as string); + break; + case SimConnectDataType.STRING32: + rawBuffer.writeString32(value as string); + break; + case SimConnectDataType.STRING64: + rawBuffer.writeString64(value as string); + break; + case SimConnectDataType.STRING128: + rawBuffer.writeString128(value as string); + break; + case SimConnectDataType.STRING256: + rawBuffer.writeString256(value as string); + break; + case SimConnectDataType.STRING260: + rawBuffer.writeString260(value as string); + break; + case SimConnectDataType.STRINGV: + rawBuffer.writeString(value as string); + break; + default: + // TODO: implement writing of the struct types + throw Error(`Unhandled data type: ${dataType} (${SimConnectDataType[dataType]})`); } } // Types: -type VariableRequestDefinition = { - simulationVariable: string; +type SimulationVariable = { units: string | null; dataType: SimConnectDataType; - epsilon?: number | undefined; + epsilon?: number; +}; + +type VariablesToSet = { + [propName: string]: SimulationVariable & { + value: JavascriptDataType[SimulationVariable['dataType']]; + }; }; -type RequestedVariables = { - [propName: string]: VariableRequestDefinition; +type VariablesToGet = { + [propName: string]: SimulationVariable; }; -type VariablesResponse = { - [K in keyof R]: OutputVariableType[R[K]['dataType']]; +type VariablesResponse = { + [K in keyof R]: JavascriptDataType[R[K]['dataType']]; }; /** Maps the SimConnect data types to JS data types */ -type OutputVariableType = { +type JavascriptDataType = { [T in SimConnectDataType]: { [SimConnectDataType.INVALID]: undefined; [SimConnectDataType.INT32]: number; diff --git a/src/ApiHelper/SystemEventsHelper.ts b/src/ApiHelper/SystemEventsHelper.ts index adaea6b..bdf103f 100644 --- a/src/ApiHelper/SystemEventsHelper.ts +++ b/src/ApiHelper/SystemEventsHelper.ts @@ -1,15 +1,13 @@ import { SimConnectConnection } from '../SimConnectConnection'; -import { checkForExceptions } from './utils'; +import { BaseHelper } from './BaseHelper'; -export class SystemEventsHelper { - _nextClientEventId; +export class SystemEventsHelper extends BaseHelper { + private _nextClientEventId; - _handle: SimConnectConnection; - - _subscriptions: { [systemEventName: string]: EventSubscription }; + private readonly _subscriptions: { [systemEventName: string]: EventSubscription }; constructor(handle: SimConnectConnection) { - this._handle = handle; + super(handle); this._nextClientEventId = 0; this._subscriptions = {}; @@ -38,7 +36,7 @@ export class SystemEventsHelper { systemEventName ); this._nextClientEventId++; - checkForExceptions(this._handle, sendId, ex => { + this._checkForException(sendId, ex => { throw Error(`Subscription for system event '${systemEventName}' failed: ${ex}`); }); } @@ -54,7 +52,7 @@ export class SystemEventsHelper { if (sub.eventHandlers.length === 0) { const sendId = this._handle.unsubscribeFromSystemEvent(sub.clientEventId); delete this._subscriptions[systemEventName]; - checkForExceptions(this._handle, sendId, ex => { + this._checkForException(sendId, ex => { throw Error(`Unsubscription for system event '${systemEventName}' failed: ${ex}`); }); } diff --git a/src/ApiHelper/utils.ts b/src/ApiHelper/utils.ts deleted file mode 100644 index 95d5549..0000000 --- a/src/ApiHelper/utils.ts +++ /dev/null @@ -1,22 +0,0 @@ -import { RecvException } from '../recv'; -import { SimConnectException } from '../enums/SimConnectException'; -import { SimConnectConnection } from '../SimConnectConnection'; - -export function checkForExceptions( - connection: SimConnectConnection, - sendId: number, - handler: (exception: string) => void -) { - function exceptionHandler(recvException: RecvException) { - if (recvException.sendId === sendId) { - handler(SimConnectException[recvException.exception]); - } - } - - connection.on('exception', exceptionHandler); - - // Give SimConnect server some time to throw the exception, then remove the listener - setTimeout(() => { - connection.off('exception', exceptionHandler); - }, 1000); -} From dfcb170765c6aaa1ef3af3023bc66a1004a86dc8 Mon Sep 17 00:00:00 2001 From: Even Rognlien Date: Tue, 4 Jul 2023 00:02:11 +0200 Subject: [PATCH 05/12] WIP: facilities helper --- src/ApiHelper/FacilitiesHelper.ts | 100 ++++++++++++++++ src/ApiHelper/SimulationVariablesHelper.ts | 130 +------------------- src/ApiHelper/index.ts | 4 + src/ApiHelper/utils.ts | 131 +++++++++++++++++++++ src/SimConnectConnection.ts | 1 + 5 files changed, 237 insertions(+), 129 deletions(-) create mode 100644 src/ApiHelper/FacilitiesHelper.ts create mode 100644 src/ApiHelper/utils.ts diff --git a/src/ApiHelper/FacilitiesHelper.ts b/src/ApiHelper/FacilitiesHelper.ts new file mode 100644 index 0000000..fe471dd --- /dev/null +++ b/src/ApiHelper/FacilitiesHelper.ts @@ -0,0 +1,100 @@ +import { BaseHelper } from './BaseHelper'; +import { SimConnectConnection } from '../SimConnectConnection'; +import { SimConnectDataType } from '../enums/SimConnectDataType'; +import { JavascriptDataType, readSimConnectValue } from './utils'; +import { FacilityDataType } from '../enums/FacilityDataType'; +import { RecvFacilityData } from '../recv'; + +export class FacilitiesHelper extends BaseHelper { + private _nextFacilityDefinition: number; + + private _nextRequestId: number; + + constructor(handle: SimConnectConnection) { + super(handle); + this._nextFacilityDefinition = 0; + this._nextRequestId = 0; + } + + async get(icao: string, facilityDefinition: T) { + return new Promise>(resolve => { + const defineId = this._nextFacilityDefinition++; + const requestId = this._nextRequestId++; + this._registerObject(defineId, facilityDefinition); + + this._handle.requestFacilityData(defineId, requestId, icao); + + let output = {} as FacilityOutput; + + this._handle.on('facilityData', recvFacilityData => { + output = { ...output, ...readObject(facilityDefinition, recvFacilityData, output) }; + }); + + this._handle.on('facilityDataEnd', recvFacilityDataEnd => { + if (recvFacilityDataEnd.userRequestId === requestId) { + resolve(output); + } + }); + }); + } + + private _registerObject(defineId: number, definition: FacilityDefinition) { + const names = Object.keys(definition); + names.forEach((name, index) => { + const value = definition[name]; + if (typeof value === 'object') { + this._handle.addToFacilityDefinition(defineId, `OPEN ${name}`); + this._registerObject(defineId, value); + } else if (index === names.length - 1) { + this._handle.addToFacilityDefinition(defineId, `CLOSE ${name}`); + } else { + this._handle.addToFacilityDefinition(defineId, name); + } + }); + } +} + +/** + * Reads the facility data recursively based on the user defined structure + */ +function readObject( + facilityDefinition: T, + recvData: RecvFacilityData, + accumulated: FacilityOutput +): FacilityOutput { + const output = accumulated; + + Object.keys(facilityDefinition).forEach((propName: keyof T) => { + const valueToRead: SimConnectDataType | FacilityDefinition = facilityDefinition[propName]; + if (typeof valueToRead === 'object') { + /** + * The data type we received should match one of the propnames of facilityDefinition (AIRPORT, RUNWAY, FREQUENCY, etc). + * Does the current propname match? + */ + if (propName === FacilityDataType[recvData.type]) { + // We will be reading a facility data type + output[propName] = readObject( + valueToRead, + recvData, + output + ) as FacilityOutput[typeof propName]; + } + // Nope, check next propName + } else { + // The current prop is a value + output[propName] = readSimConnectValue( + recvData.data, + valueToRead + ) as FacilityOutput[typeof propName]; + } + }); + return output; +} + +type FacilityOutput = { + [K in keyof T]: T[K] extends SimConnectDataType ? JavascriptDataType[T[K]] : FacilityOutput; +}; + +type FacilityDefinition = { + [dataName: string]: SimConnectDataType | FacilityDefinition; +}; diff --git a/src/ApiHelper/SimulationVariablesHelper.ts b/src/ApiHelper/SimulationVariablesHelper.ts index f321b11..efc6778 100644 --- a/src/ApiHelper/SimulationVariablesHelper.ts +++ b/src/ApiHelper/SimulationVariablesHelper.ts @@ -7,18 +7,7 @@ import { RawBuffer } from '../RawBuffer'; import { SimObjectType } from '../enums/SimObjectType'; import { SimConnectException } from '../enums/SimConnectException'; import { BaseHelper } from './BaseHelper'; -import { - InitPosition, - LatLonAlt, - MarkerState, - readInitPosition, - readLatLonAlt, - readMarkerState, - readWaypoint, - readXYZ, - Waypoint, - XYZ, -} from '../dto'; +import { JavascriptDataType, readSimConnectValue, writeSimConnectValue } from './utils'; export type SimvarCallback = ( err: SimConnectError | null, @@ -305,99 +294,6 @@ function extractDataStructureFromBuffer( ); } -function readSimConnectValue( - rawBuffer: RawBuffer, - dataType: T -): JavascriptDataType[T] { - switch (dataType) { - case SimConnectDataType.INVALID: - return undefined as JavascriptDataType[T]; - case SimConnectDataType.INT32: - return rawBuffer.readInt32() as JavascriptDataType[T]; - case SimConnectDataType.INT64: - return rawBuffer.readInt64() as JavascriptDataType[T]; - case SimConnectDataType.FLOAT32: - return rawBuffer.readFloat32() as JavascriptDataType[T]; - case SimConnectDataType.FLOAT64: - return rawBuffer.readFloat64() as JavascriptDataType[T]; - case SimConnectDataType.STRING8: - return rawBuffer.readString8() as JavascriptDataType[T]; - case SimConnectDataType.STRING32: - return rawBuffer.readString32() as JavascriptDataType[T]; - case SimConnectDataType.STRING64: - return rawBuffer.readString64() as JavascriptDataType[T]; - case SimConnectDataType.STRING128: - return rawBuffer.readString128() as JavascriptDataType[T]; - case SimConnectDataType.STRING256: - return rawBuffer.readString256() as JavascriptDataType[T]; - case SimConnectDataType.STRING260: - return rawBuffer.readString260() as JavascriptDataType[T]; - case SimConnectDataType.STRINGV: - return rawBuffer.readStringV() as JavascriptDataType[T]; - case SimConnectDataType.INITPOSITION: - return readInitPosition(rawBuffer) as JavascriptDataType[T]; - case SimConnectDataType.MARKERSTATE: - return readMarkerState(rawBuffer) as JavascriptDataType[T]; - case SimConnectDataType.WAYPOINT: - return readWaypoint(rawBuffer) as JavascriptDataType[T]; - case SimConnectDataType.LATLONALT: - return readLatLonAlt(rawBuffer) as JavascriptDataType[T]; - case SimConnectDataType.XYZ: - return readXYZ(rawBuffer) as JavascriptDataType[T]; - case SimConnectDataType.MAX: - return undefined as JavascriptDataType[T]; - default: - return undefined as JavascriptDataType[T]; - } -} - -function writeSimConnectValue( - rawBuffer: RawBuffer, - value: JavascriptDataType[T], - dataType: T -) { - switch (dataType) { - case SimConnectDataType.INVALID: - break; - case SimConnectDataType.INT32: - rawBuffer.writeInt32(value as number); - break; - case SimConnectDataType.INT64: - rawBuffer.writeInt64(value as number); - break; - case SimConnectDataType.FLOAT32: - rawBuffer.writeFloat32(value as number); - break; - case SimConnectDataType.FLOAT64: - rawBuffer.writeFloat64(value as number); - break; - case SimConnectDataType.STRING8: - rawBuffer.writeString8(value as string); - break; - case SimConnectDataType.STRING32: - rawBuffer.writeString32(value as string); - break; - case SimConnectDataType.STRING64: - rawBuffer.writeString64(value as string); - break; - case SimConnectDataType.STRING128: - rawBuffer.writeString128(value as string); - break; - case SimConnectDataType.STRING256: - rawBuffer.writeString256(value as string); - break; - case SimConnectDataType.STRING260: - rawBuffer.writeString260(value as string); - break; - case SimConnectDataType.STRINGV: - rawBuffer.writeString(value as string); - break; - default: - // TODO: implement writing of the struct types - throw Error(`Unhandled data type: ${dataType} (${SimConnectDataType[dataType]})`); - } -} - // Types: type SimulationVariable = { @@ -420,28 +316,4 @@ type VariablesResponse = { [K in keyof R]: JavascriptDataType[R[K]['dataType']]; }; -/** Maps the SimConnect data types to JS data types */ -type JavascriptDataType = { - [T in SimConnectDataType]: { - [SimConnectDataType.INVALID]: undefined; - [SimConnectDataType.INT32]: number; - [SimConnectDataType.INT64]: number; - [SimConnectDataType.FLOAT32]: number; - [SimConnectDataType.FLOAT64]: number; - [SimConnectDataType.STRING8]: string; - [SimConnectDataType.STRING32]: string; - [SimConnectDataType.STRING64]: string; - [SimConnectDataType.STRING128]: string; - [SimConnectDataType.STRING256]: string; - [SimConnectDataType.STRING260]: string; - [SimConnectDataType.STRINGV]: string; - [SimConnectDataType.INITPOSITION]: InitPosition; - [SimConnectDataType.MARKERSTATE]: MarkerState; - [SimConnectDataType.WAYPOINT]: Waypoint; - [SimConnectDataType.LATLONALT]: LatLonAlt; - [SimConnectDataType.XYZ]: XYZ; - [SimConnectDataType.MAX]: undefined; - }[T]; -}; - export { SimulationVariablesHelper }; diff --git a/src/ApiHelper/index.ts b/src/ApiHelper/index.ts index c9a510e..6015769 100644 --- a/src/ApiHelper/index.ts +++ b/src/ApiHelper/index.ts @@ -1,14 +1,18 @@ import { SimConnectConnection } from '../SimConnectConnection'; import { SimulationVariablesHelper } from './SimulationVariablesHelper'; import { SystemEventsHelper } from './SystemEventsHelper'; +import { FacilitiesHelper } from './FacilitiesHelper'; export class ApiHelper { simulationVariables: SimulationVariablesHelper; systemEvents: SystemEventsHelper; + facilities: FacilitiesHelper; + constructor(handle: SimConnectConnection) { this.simulationVariables = new SimulationVariablesHelper(handle); this.systemEvents = new SystemEventsHelper(handle); + this.facilities = new FacilitiesHelper(handle); } } diff --git a/src/ApiHelper/utils.ts b/src/ApiHelper/utils.ts new file mode 100644 index 0000000..36b2eb1 --- /dev/null +++ b/src/ApiHelper/utils.ts @@ -0,0 +1,131 @@ +import { SimConnectDataType } from '../enums/SimConnectDataType'; +import { RawBuffer } from '../RawBuffer'; +import { + InitPosition, + LatLonAlt, + MarkerState, + readInitPosition, + readLatLonAlt, + readMarkerState, + readWaypoint, + readXYZ, + Waypoint, + XYZ, +} from '../dto'; + +export function readSimConnectValue( + rawBuffer: RawBuffer, + dataType: T +): JavascriptDataType[T] { + switch (dataType) { + case SimConnectDataType.INVALID: + return undefined as JavascriptDataType[T]; + case SimConnectDataType.INT32: + return rawBuffer.readInt32() as JavascriptDataType[T]; + case SimConnectDataType.INT64: + return rawBuffer.readInt64() as JavascriptDataType[T]; + case SimConnectDataType.FLOAT32: + return rawBuffer.readFloat32() as JavascriptDataType[T]; + case SimConnectDataType.FLOAT64: + return rawBuffer.readFloat64() as JavascriptDataType[T]; + case SimConnectDataType.STRING8: + return rawBuffer.readString8() as JavascriptDataType[T]; + case SimConnectDataType.STRING32: + return rawBuffer.readString32() as JavascriptDataType[T]; + case SimConnectDataType.STRING64: + return rawBuffer.readString64() as JavascriptDataType[T]; + case SimConnectDataType.STRING128: + return rawBuffer.readString128() as JavascriptDataType[T]; + case SimConnectDataType.STRING256: + return rawBuffer.readString256() as JavascriptDataType[T]; + case SimConnectDataType.STRING260: + return rawBuffer.readString260() as JavascriptDataType[T]; + case SimConnectDataType.STRINGV: + return rawBuffer.readStringV() as JavascriptDataType[T]; + case SimConnectDataType.INITPOSITION: + return readInitPosition(rawBuffer) as JavascriptDataType[T]; + case SimConnectDataType.MARKERSTATE: + return readMarkerState(rawBuffer) as JavascriptDataType[T]; + case SimConnectDataType.WAYPOINT: + return readWaypoint(rawBuffer) as JavascriptDataType[T]; + case SimConnectDataType.LATLONALT: + return readLatLonAlt(rawBuffer) as JavascriptDataType[T]; + case SimConnectDataType.XYZ: + return readXYZ(rawBuffer) as JavascriptDataType[T]; + case SimConnectDataType.MAX: + return undefined as JavascriptDataType[T]; + default: + return undefined as JavascriptDataType[T]; + } +} + +export function writeSimConnectValue( + rawBuffer: RawBuffer, + value: JavascriptDataType[T], + dataType: T +) { + switch (dataType) { + case SimConnectDataType.INVALID: + break; + case SimConnectDataType.INT32: + rawBuffer.writeInt32(value as number); + break; + case SimConnectDataType.INT64: + rawBuffer.writeInt64(value as number); + break; + case SimConnectDataType.FLOAT32: + rawBuffer.writeFloat32(value as number); + break; + case SimConnectDataType.FLOAT64: + rawBuffer.writeFloat64(value as number); + break; + case SimConnectDataType.STRING8: + rawBuffer.writeString8(value as string); + break; + case SimConnectDataType.STRING32: + rawBuffer.writeString32(value as string); + break; + case SimConnectDataType.STRING64: + rawBuffer.writeString64(value as string); + break; + case SimConnectDataType.STRING128: + rawBuffer.writeString128(value as string); + break; + case SimConnectDataType.STRING256: + rawBuffer.writeString256(value as string); + break; + case SimConnectDataType.STRING260: + rawBuffer.writeString260(value as string); + break; + case SimConnectDataType.STRINGV: + rawBuffer.writeString(value as string); + break; + default: + // TODO: implement writing of the struct types + throw Error(`Unhandled data type: ${dataType} (${SimConnectDataType[dataType]})`); + } +} + +/** Maps the SimConnect data types to JS data types */ +export type JavascriptDataType = { + [T in SimConnectDataType]: { + [SimConnectDataType.INVALID]: undefined; + [SimConnectDataType.INT32]: number; + [SimConnectDataType.INT64]: number; + [SimConnectDataType.FLOAT32]: number; + [SimConnectDataType.FLOAT64]: number; + [SimConnectDataType.STRING8]: string; + [SimConnectDataType.STRING32]: string; + [SimConnectDataType.STRING64]: string; + [SimConnectDataType.STRING128]: string; + [SimConnectDataType.STRING256]: string; + [SimConnectDataType.STRING260]: string; + [SimConnectDataType.STRINGV]: string; + [SimConnectDataType.INITPOSITION]: InitPosition; + [SimConnectDataType.MARKERSTATE]: MarkerState; + [SimConnectDataType.WAYPOINT]: Waypoint; + [SimConnectDataType.LATLONALT]: LatLonAlt; + [SimConnectDataType.XYZ]: XYZ; + [SimConnectDataType.MAX]: undefined; + }[T]; +}; diff --git a/src/SimConnectConnection.ts b/src/SimConnectConnection.ts index 2c7f7d7..08c2208 100644 --- a/src/SimConnectConnection.ts +++ b/src/SimConnectConnection.ts @@ -1413,6 +1413,7 @@ class SimConnectConnection extends EventEmitter { * @returns sendId of packet (can be used to identify packet when exception event occurs) */ addToFacilityDefinition(dataDefinitionId: DataDefinitionId, fieldName: string): number { + console.log(fieldName); if (this._ourProtocol < Protocol.KittyHawk) throw Error(SimConnectError.BadVersion); return this._buildAndSend( From 6a0a93fc5120e6649984b7829edce482242d4e54 Mon Sep 17 00:00:00 2001 From: Even Rognlien Date: Tue, 30 Jan 2024 20:29:58 +0100 Subject: [PATCH 06/12] Rebase master --- package-lock.json | 4912 +---------------------------- samples/typescript/apiHelper.ts | 18 +- src/ApiHelper/FacilitiesHelper.ts | 253 +- src/SimConnectConnection.ts | 1 - 4 files changed, 252 insertions(+), 4932 deletions(-) diff --git a/package-lock.json b/package-lock.json index fb25a6c..3dc8c29 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "node-simconnect", - "version": "4.0.0", - "lockfileVersion": 2, + "version": "3.6.1", + "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "node-simconnect", - "version": "4.0.0", + "version": "3.6.1", "license": "LGPL-3.0-or-later", "dependencies": { "@types/node": "*", @@ -1068,12 +1068,6 @@ "@jridgewell/sourcemap-codec": "1.4.14" } }, - "node_modules/@microsoft/tsdoc": { - "version": "0.14.2", - "resolved": "https://registry.npmjs.org/@microsoft/tsdoc/-/tsdoc-0.14.2.tgz", - "integrity": "sha512-9b8mPpKrfeGRuhFH5iO1iwCLeIIsV6+H1sRfxbkoGXIyQE2BTsPd9zqSqQJ+pv5sJ/hT5M1zvOFL02MnEezFug==", - "dev": true - }, "node_modules/@microsoft/tsdoc-config": { "version": "0.16.2", "resolved": "https://registry.npmjs.org/@microsoft/tsdoc-config/-/tsdoc-config-0.16.2.tgz", @@ -1086,6 +1080,12 @@ "resolve": "~1.19.0" } }, + "node_modules/@microsoft/tsdoc-config/node_modules/@microsoft/tsdoc": { + "version": "0.14.2", + "resolved": "https://registry.npmjs.org/@microsoft/tsdoc/-/tsdoc-0.14.2.tgz", + "integrity": "sha512-9b8mPpKrfeGRuhFH5iO1iwCLeIIsV6+H1sRfxbkoGXIyQE2BTsPd9zqSqQJ+pv5sJ/hT5M1zvOFL02MnEezFug==", + "dev": true + }, "node_modules/@nodelib/fs.scandir": { "version": "2.1.5", "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", @@ -2771,6 +2771,12 @@ "@microsoft/tsdoc-config": "0.16.2" } }, + "node_modules/eslint-plugin-tsdoc/node_modules/@microsoft/tsdoc": { + "version": "0.14.2", + "resolved": "https://registry.npmjs.org/@microsoft/tsdoc/-/tsdoc-0.14.2.tgz", + "integrity": "sha512-9b8mPpKrfeGRuhFH5iO1iwCLeIIsV6+H1sRfxbkoGXIyQE2BTsPd9zqSqQJ+pv5sJ/hT5M1zvOFL02MnEezFug==", + "dev": true + }, "node_modules/eslint-scope": { "version": "7.1.1", "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz", @@ -3249,13 +3255,10 @@ } }, "node_modules/function-bind": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", - "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", - "dev": true, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true }, "node_modules/function.prototype.name": { "version": "1.1.5", @@ -3495,18 +3498,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/hasown": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.0.tgz", - "integrity": "sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==", - "dev": true, - "dependencies": { - "function-bind": "^1.1.2" - }, - "engines": { - "node": ">= 0.4" - } - }, "node_modules/html-escaper": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", @@ -3697,12 +3688,12 @@ } }, "node_modules/is-core-module": { - "version": "2.13.1", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.13.1.tgz", - "integrity": "sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==", + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz", + "integrity": "sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==", "dev": true, "dependencies": { - "hasown": "^2.0.0" + "has": "^1.0.3" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -4738,9 +4729,9 @@ } }, "node_modules/jsonc-parser": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz", - "integrity": "sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==", + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.1.tgz", + "integrity": "sha512-AilxAyFOAcK5wA1+LeaySVBrHsGQvUFCDWXKpZjzaL0PqW+xfBOttn8GNtWKFWqneyMZj41MWF9Kl6iPWLwgOA==", "dev": true }, "node_modules/kleur": { @@ -6257,15 +6248,15 @@ } }, "node_modules/typedoc": { - "version": "0.25.4", - "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.25.4.tgz", - "integrity": "sha512-Du9ImmpBCw54bX275yJrxPVnjdIyJO/84co0/L9mwe0R3G4FSR6rQ09AlXVRvZEGMUg09+z/usc8mgygQ1aidA==", + "version": "0.25.7", + "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.25.7.tgz", + "integrity": "sha512-m6A6JjQRg39p2ZVRIN3NKXgrN8vzlHhOS+r9ymUYtcUP/TIQPvWSq7YgE5ZjASfv5Vd5BW5xrir6Gm2XNNcOow==", "dev": true, "dependencies": { "lunr": "^2.3.9", "marked": "^4.3.0", "minimatch": "^9.0.3", - "shiki": "^0.14.1" + "shiki": "^0.14.7" }, "bin": { "typedoc": "bin/typedoc" @@ -6555,4848 +6546,5 @@ "url": "https://github.com/sponsors/sindresorhus" } } - }, - "dependencies": { - "@ampproject/remapping": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.0.tgz", - "integrity": "sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==", - "dev": true, - "requires": { - "@jridgewell/gen-mapping": "^0.1.0", - "@jridgewell/trace-mapping": "^0.3.9" - } - }, - "@babel/code-frame": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", - "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", - "dev": true, - "requires": { - "@babel/highlight": "^7.18.6" - } - }, - "@babel/compat-data": { - "version": "7.20.5", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.20.5.tgz", - "integrity": "sha512-KZXo2t10+/jxmkhNXc7pZTqRvSOIvVv/+lJwHS+B2rErwOyjuVRh60yVpb7liQ1U5t7lLJ1bz+t8tSypUZdm0g==", - "dev": true - }, - "@babel/core": { - "version": "7.20.5", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.20.5.tgz", - "integrity": "sha512-UdOWmk4pNWTm/4DlPUl/Pt4Gz4rcEMb7CY0Y3eJl5Yz1vI8ZJGmHWaVE55LoxRjdpx0z259GE9U5STA9atUinQ==", - "dev": true, - "requires": { - "@ampproject/remapping": "^2.1.0", - "@babel/code-frame": "^7.18.6", - "@babel/generator": "^7.20.5", - "@babel/helper-compilation-targets": "^7.20.0", - "@babel/helper-module-transforms": "^7.20.2", - "@babel/helpers": "^7.20.5", - "@babel/parser": "^7.20.5", - "@babel/template": "^7.18.10", - "@babel/traverse": "^7.20.5", - "@babel/types": "^7.20.5", - "convert-source-map": "^1.7.0", - "debug": "^4.1.0", - "gensync": "^1.0.0-beta.2", - "json5": "^2.2.1", - "semver": "^6.3.0" - }, - "dependencies": { - "convert-source-map": { - "version": "1.9.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", - "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", - "dev": true - } - } - }, - "@babel/generator": { - "version": "7.20.5", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.20.5.tgz", - "integrity": "sha512-jl7JY2Ykn9S0yj4DQP82sYvPU+T3g0HFcWTqDLqiuA9tGRNIj9VfbtXGAYTTkyNEnQk1jkMGOdYka8aG/lulCA==", - "dev": true, - "requires": { - "@babel/types": "^7.20.5", - "@jridgewell/gen-mapping": "^0.3.2", - "jsesc": "^2.5.1" - }, - "dependencies": { - "@jridgewell/gen-mapping": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz", - "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==", - "dev": true, - "requires": { - "@jridgewell/set-array": "^1.0.1", - "@jridgewell/sourcemap-codec": "^1.4.10", - "@jridgewell/trace-mapping": "^0.3.9" - } - } - } - }, - "@babel/helper-compilation-targets": { - "version": "7.20.0", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.0.tgz", - "integrity": "sha512-0jp//vDGp9e8hZzBc6N/KwA5ZK3Wsm/pfm4CrY7vzegkVxc65SgSn6wYOnwHe9Js9HRQ1YTCKLGPzDtaS3RoLQ==", - "dev": true, - "requires": { - "@babel/compat-data": "^7.20.0", - "@babel/helper-validator-option": "^7.18.6", - "browserslist": "^4.21.3", - "semver": "^6.3.0" - } - }, - "@babel/helper-environment-visitor": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz", - "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==", - "dev": true - }, - "@babel/helper-function-name": { - "version": "7.19.0", - "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.19.0.tgz", - "integrity": "sha512-WAwHBINyrpqywkUH0nTnNgI5ina5TFn85HKS0pbPDfxFfhyR/aNQEn4hGi1P1JyT//I0t4OgXUlofzWILRvS5w==", - "dev": true, - "requires": { - "@babel/template": "^7.18.10", - "@babel/types": "^7.19.0" - } - }, - "@babel/helper-hoist-variables": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz", - "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==", - "dev": true, - "requires": { - "@babel/types": "^7.18.6" - } - }, - "@babel/helper-module-imports": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", - "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", - "dev": true, - "requires": { - "@babel/types": "^7.18.6" - } - }, - "@babel/helper-module-transforms": { - "version": "7.20.2", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.20.2.tgz", - "integrity": "sha512-zvBKyJXRbmK07XhMuujYoJ48B5yvvmM6+wcpv6Ivj4Yg6qO7NOZOSnvZN9CRl1zz1Z4cKf8YejmCMh8clOoOeA==", - "dev": true, - "requires": { - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-module-imports": "^7.18.6", - "@babel/helper-simple-access": "^7.20.2", - "@babel/helper-split-export-declaration": "^7.18.6", - "@babel/helper-validator-identifier": "^7.19.1", - "@babel/template": "^7.18.10", - "@babel/traverse": "^7.20.1", - "@babel/types": "^7.20.2" - } - }, - "@babel/helper-plugin-utils": { - "version": "7.20.2", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.20.2.tgz", - "integrity": "sha512-8RvlJG2mj4huQ4pZ+rU9lqKi9ZKiRmuvGuM2HlWmkmgOhbs6zEAw6IEiJ5cQqGbDzGZOhwuOQNtZMi/ENLjZoQ==", - "dev": true - }, - "@babel/helper-simple-access": { - "version": "7.20.2", - "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz", - "integrity": "sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA==", - "dev": true, - "requires": { - "@babel/types": "^7.20.2" - } - }, - "@babel/helper-split-export-declaration": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz", - "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==", - "dev": true, - "requires": { - "@babel/types": "^7.18.6" - } - }, - "@babel/helper-string-parser": { - "version": "7.19.4", - "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.19.4.tgz", - "integrity": "sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw==", - "dev": true - }, - "@babel/helper-validator-identifier": { - "version": "7.19.1", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz", - "integrity": "sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==", - "dev": true - }, - "@babel/helper-validator-option": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.18.6.tgz", - "integrity": "sha512-XO7gESt5ouv/LRJdrVjkShckw6STTaB7l9BrpBaAHDeF5YZT+01PCwmR0SJHnkW6i8OwW/EVWRShfi4j2x+KQw==", - "dev": true - }, - "@babel/helpers": { - "version": "7.20.6", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.20.6.tgz", - "integrity": "sha512-Pf/OjgfgFRW5bApskEz5pvidpim7tEDPlFtKcNRXWmfHGn9IEI2W2flqRQXTFb7gIPTyK++N6rVHuwKut4XK6w==", - "dev": true, - "requires": { - "@babel/template": "^7.18.10", - "@babel/traverse": "^7.20.5", - "@babel/types": "^7.20.5" - } - }, - "@babel/highlight": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", - "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", - "dev": true, - "requires": { - "@babel/helper-validator-identifier": "^7.18.6", - "chalk": "^2.0.0", - "js-tokens": "^4.0.0" - }, - "dependencies": { - "ansi-styles": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", - "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", - "dev": true, - "requires": { - "color-convert": "^1.9.0" - } - }, - "chalk": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", - "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", - "dev": true, - "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" - } - }, - "color-convert": { - "version": "1.9.3", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", - "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", - "dev": true, - "requires": { - "color-name": "1.1.3" - } - }, - "color-name": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", - "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", - "dev": true - }, - "escape-string-regexp": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", - "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", - "dev": true - }, - "has-flag": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", - "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", - "dev": true - }, - "supports-color": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", - "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", - "dev": true, - "requires": { - "has-flag": "^3.0.0" - } - } - } - }, - "@babel/parser": { - "version": "7.20.5", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.20.5.tgz", - "integrity": "sha512-r27t/cy/m9uKLXQNWWebeCUHgnAZq0CpG1OwKRxzJMP1vpSU4bSIK2hq+/cp0bQxetkXx38n09rNu8jVkcK/zA==", - "dev": true - }, - "@babel/plugin-syntax-async-generators": { - "version": "7.8.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", - "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.8.0" - } - }, - "@babel/plugin-syntax-bigint": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz", - "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.8.0" - } - }, - "@babel/plugin-syntax-class-properties": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", - "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.12.13" - } - }, - "@babel/plugin-syntax-import-meta": { - "version": "7.10.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", - "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.10.4" - } - }, - "@babel/plugin-syntax-json-strings": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", - "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.8.0" - } - }, - "@babel/plugin-syntax-jsx": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.18.6.tgz", - "integrity": "sha512-6mmljtAedFGTWu2p/8WIORGwy+61PLgOMPOdazc7YoJ9ZCWUyFy3A6CpPkRKLKD1ToAesxX8KGEViAiLo9N+7Q==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.18.6" - } - }, - "@babel/plugin-syntax-logical-assignment-operators": { - "version": "7.10.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", - "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.10.4" - } - }, - "@babel/plugin-syntax-nullish-coalescing-operator": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", - "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.8.0" - } - }, - "@babel/plugin-syntax-numeric-separator": { - "version": "7.10.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", - "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.10.4" - } - }, - "@babel/plugin-syntax-object-rest-spread": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", - "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.8.0" - } - }, - "@babel/plugin-syntax-optional-catch-binding": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", - "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.8.0" - } - }, - "@babel/plugin-syntax-optional-chaining": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", - "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.8.0" - } - }, - "@babel/plugin-syntax-top-level-await": { - "version": "7.14.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", - "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.14.5" - } - }, - "@babel/plugin-syntax-typescript": { - "version": "7.20.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.20.0.tgz", - "integrity": "sha512-rd9TkG+u1CExzS4SM1BlMEhMXwFLKVjOAFFCDx9PbX5ycJWDoWMcwdJH9RhkPu1dOgn5TrxLot/Gx6lWFuAUNQ==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.19.0" - } - }, - "@babel/template": { - "version": "7.18.10", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.10.tgz", - "integrity": "sha512-TI+rCtooWHr3QJ27kJxfjutghu44DLnasDMwpDqCXVTal9RLp3RSYNh4NdBrRP2cQAoG9A8juOQl6P6oZG4JxA==", - "dev": true, - "requires": { - "@babel/code-frame": "^7.18.6", - "@babel/parser": "^7.18.10", - "@babel/types": "^7.18.10" - } - }, - "@babel/traverse": { - "version": "7.20.5", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.20.5.tgz", - "integrity": "sha512-WM5ZNN3JITQIq9tFZaw1ojLU3WgWdtkxnhM1AegMS+PvHjkM5IXjmYEGY7yukz5XS4sJyEf2VzWjI8uAavhxBQ==", - "dev": true, - "requires": { - "@babel/code-frame": "^7.18.6", - "@babel/generator": "^7.20.5", - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-function-name": "^7.19.0", - "@babel/helper-hoist-variables": "^7.18.6", - "@babel/helper-split-export-declaration": "^7.18.6", - "@babel/parser": "^7.20.5", - "@babel/types": "^7.20.5", - "debug": "^4.1.0", - "globals": "^11.1.0" - } - }, - "@babel/types": { - "version": "7.20.5", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.20.5.tgz", - "integrity": "sha512-c9fst/h2/dcF7H+MJKZ2T0KjEQ8hY/BNnDk/H3XY8C4Aw/eWQXWn/lWntHF9ooUBnGmEvbfGrTgLWc+um0YDUg==", - "dev": true, - "requires": { - "@babel/helper-string-parser": "^7.19.4", - "@babel/helper-validator-identifier": "^7.19.1", - "to-fast-properties": "^2.0.0" - } - }, - "@bcoe/v8-coverage": { - "version": "0.2.3", - "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", - "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", - "dev": true - }, - "@eslint/eslintrc": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-1.3.0.tgz", - "integrity": "sha512-UWW0TMTmk2d7hLcWD1/e2g5HDM/HQ3csaLSqXCfqwh4uNDuNqlaKWXmEsL4Cs41Z0KnILNvwbHAah3C2yt06kw==", - "dev": true, - "requires": { - "ajv": "^6.12.4", - "debug": "^4.3.2", - "espree": "^9.3.2", - "globals": "^13.15.0", - "ignore": "^5.2.0", - "import-fresh": "^3.2.1", - "js-yaml": "^4.1.0", - "minimatch": "^3.1.2", - "strip-json-comments": "^3.1.1" - }, - "dependencies": { - "argparse": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", - "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", - "dev": true - }, - "globals": { - "version": "13.15.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.15.0.tgz", - "integrity": "sha512-bpzcOlgDhMG070Av0Vy5Owklpv1I6+j96GhUI7Rh7IzDCKLzboflLrrfqMu8NquDbiR4EOQk7XzJwqVJxicxog==", - "dev": true, - "requires": { - "type-fest": "^0.20.2" - } - }, - "js-yaml": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", - "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", - "dev": true, - "requires": { - "argparse": "^2.0.1" - } - }, - "type-fest": { - "version": "0.20.2", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", - "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", - "dev": true - } - } - }, - "@humanwhocodes/config-array": { - "version": "0.9.5", - "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.9.5.tgz", - "integrity": "sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==", - "dev": true, - "requires": { - "@humanwhocodes/object-schema": "^1.2.1", - "debug": "^4.1.1", - "minimatch": "^3.0.4" - } - }, - "@humanwhocodes/object-schema": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", - "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", - "dev": true - }, - "@istanbuljs/load-nyc-config": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", - "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==", - "dev": true, - "requires": { - "camelcase": "^5.3.1", - "find-up": "^4.1.0", - "get-package-type": "^0.1.0", - "js-yaml": "^3.13.1", - "resolve-from": "^5.0.0" - } - }, - "@istanbuljs/schema": { - "version": "0.1.3", - "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", - "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", - "dev": true - }, - "@jest/console": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/console/-/console-29.3.1.tgz", - "integrity": "sha512-IRE6GD47KwcqA09RIWrabKdHPiKDGgtAL31xDxbi/RjQMsr+lY+ppxmHwY0dUEV3qvvxZzoe5Hl0RXZJOjQNUg==", - "dev": true, - "requires": { - "@jest/types": "^29.3.1", - "@types/node": "*", - "chalk": "^4.0.0", - "jest-message-util": "^29.3.1", - "jest-util": "^29.3.1", - "slash": "^3.0.0" - } - }, - "@jest/core": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/core/-/core-29.3.1.tgz", - "integrity": "sha512-0ohVjjRex985w5MmO5L3u5GR1O30DexhBSpuwx2P+9ftyqHdJXnk7IUWiP80oHMvt7ubHCJHxV0a0vlKVuZirw==", - "dev": true, - "requires": { - "@jest/console": "^29.3.1", - "@jest/reporters": "^29.3.1", - "@jest/test-result": "^29.3.1", - "@jest/transform": "^29.3.1", - "@jest/types": "^29.3.1", - "@types/node": "*", - "ansi-escapes": "^4.2.1", - "chalk": "^4.0.0", - "ci-info": "^3.2.0", - "exit": "^0.1.2", - "graceful-fs": "^4.2.9", - "jest-changed-files": "^29.2.0", - "jest-config": "^29.3.1", - "jest-haste-map": "^29.3.1", - "jest-message-util": "^29.3.1", - "jest-regex-util": "^29.2.0", - "jest-resolve": "^29.3.1", - "jest-resolve-dependencies": "^29.3.1", - "jest-runner": "^29.3.1", - "jest-runtime": "^29.3.1", - "jest-snapshot": "^29.3.1", - "jest-util": "^29.3.1", - "jest-validate": "^29.3.1", - "jest-watcher": "^29.3.1", - "micromatch": "^4.0.4", - "pretty-format": "^29.3.1", - "slash": "^3.0.0", - "strip-ansi": "^6.0.0" - } - }, - "@jest/environment": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-29.3.1.tgz", - "integrity": "sha512-pMmvfOPmoa1c1QpfFW0nXYtNLpofqo4BrCIk6f2kW4JFeNlHV2t3vd+3iDLf31e2ot2Mec0uqZfmI+U0K2CFag==", - "dev": true, - "requires": { - "@jest/fake-timers": "^29.3.1", - "@jest/types": "^29.3.1", - "@types/node": "*", - "jest-mock": "^29.3.1" - } - }, - "@jest/expect": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-29.3.1.tgz", - "integrity": "sha512-QivM7GlSHSsIAWzgfyP8dgeExPRZ9BIe2LsdPyEhCGkZkoyA+kGsoIzbKAfZCvvRzfZioKwPtCZIt5SaoxYCvg==", - "dev": true, - "requires": { - "expect": "^29.3.1", - "jest-snapshot": "^29.3.1" - } - }, - "@jest/expect-utils": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-29.3.1.tgz", - "integrity": "sha512-wlrznINZI5sMjwvUoLVk617ll/UYfGIZNxmbU+Pa7wmkL4vYzhV9R2pwVqUh4NWWuLQWkI8+8mOkxs//prKQ3g==", - "dev": true, - "requires": { - "jest-get-type": "^29.2.0" - }, - "dependencies": { - "jest-get-type": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", - "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", - "dev": true - } - } - }, - "@jest/fake-timers": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-29.3.1.tgz", - "integrity": "sha512-iHTL/XpnDlFki9Tq0Q1GGuVeQ8BHZGIYsvCO5eN/O/oJaRzofG9Xndd9HuSDBI/0ZS79pg0iwn07OMTQ7ngF2A==", - "dev": true, - "requires": { - "@jest/types": "^29.3.1", - "@sinonjs/fake-timers": "^9.1.2", - "@types/node": "*", - "jest-message-util": "^29.3.1", - "jest-mock": "^29.3.1", - "jest-util": "^29.3.1" - } - }, - "@jest/globals": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-29.3.1.tgz", - "integrity": "sha512-cTicd134vOcwO59OPaB6AmdHQMCtWOe+/DitpTZVxWgMJ+YvXL1HNAmPyiGbSHmF/mXVBkvlm8YYtQhyHPnV6Q==", - "dev": true, - "requires": { - "@jest/environment": "^29.3.1", - "@jest/expect": "^29.3.1", - "@jest/types": "^29.3.1", - "jest-mock": "^29.3.1" - } - }, - "@jest/reporters": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-29.3.1.tgz", - "integrity": "sha512-GhBu3YFuDrcAYW/UESz1JphEAbvUjaY2vShRZRoRY1mxpCMB3yGSJ4j9n0GxVlEOdCf7qjvUfBCrTUUqhVfbRA==", - "dev": true, - "requires": { - "@bcoe/v8-coverage": "^0.2.3", - "@jest/console": "^29.3.1", - "@jest/test-result": "^29.3.1", - "@jest/transform": "^29.3.1", - "@jest/types": "^29.3.1", - "@jridgewell/trace-mapping": "^0.3.15", - "@types/node": "*", - "chalk": "^4.0.0", - "collect-v8-coverage": "^1.0.0", - "exit": "^0.1.2", - "glob": "^7.1.3", - "graceful-fs": "^4.2.9", - "istanbul-lib-coverage": "^3.0.0", - "istanbul-lib-instrument": "^5.1.0", - "istanbul-lib-report": "^3.0.0", - "istanbul-lib-source-maps": "^4.0.0", - "istanbul-reports": "^3.1.3", - "jest-message-util": "^29.3.1", - "jest-util": "^29.3.1", - "jest-worker": "^29.3.1", - "slash": "^3.0.0", - "string-length": "^4.0.1", - "strip-ansi": "^6.0.0", - "v8-to-istanbul": "^9.0.1" - } - }, - "@jest/schemas": { - "version": "29.0.0", - "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.0.0.tgz", - "integrity": "sha512-3Ab5HgYIIAnS0HjqJHQYZS+zXc4tUmTmBH3z83ajI6afXp8X3ZtdLX+nXx+I7LNkJD7uN9LAVhgnjDgZa2z0kA==", - "dev": true, - "requires": { - "@sinclair/typebox": "^0.24.1" - } - }, - "@jest/source-map": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-29.2.0.tgz", - "integrity": "sha512-1NX9/7zzI0nqa6+kgpSdKPK+WU1p+SJk3TloWZf5MzPbxri9UEeXX5bWZAPCzbQcyuAzubcdUHA7hcNznmRqWQ==", - "dev": true, - "requires": { - "@jridgewell/trace-mapping": "^0.3.15", - "callsites": "^3.0.0", - "graceful-fs": "^4.2.9" - } - }, - "@jest/test-result": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-29.3.1.tgz", - "integrity": "sha512-qeLa6qc0ddB0kuOZyZIhfN5q0e2htngokyTWsGriedsDhItisW7SDYZ7ceOe57Ii03sL988/03wAcBh3TChMGw==", - "dev": true, - "requires": { - "@jest/console": "^29.3.1", - "@jest/types": "^29.3.1", - "@types/istanbul-lib-coverage": "^2.0.0", - "collect-v8-coverage": "^1.0.0" - } - }, - "@jest/test-sequencer": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-29.3.1.tgz", - "integrity": "sha512-IqYvLbieTv20ArgKoAMyhLHNrVHJfzO6ARZAbQRlY4UGWfdDnLlZEF0BvKOMd77uIiIjSZRwq3Jb3Fa3I8+2UA==", - "dev": true, - "requires": { - "@jest/test-result": "^29.3.1", - "graceful-fs": "^4.2.9", - "jest-haste-map": "^29.3.1", - "slash": "^3.0.0" - } - }, - "@jest/transform": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-29.3.1.tgz", - "integrity": "sha512-8wmCFBTVGYqFNLWfcOWoVuMuKYPUBTnTMDkdvFtAYELwDOl9RGwOsvQWGPFxDJ8AWY9xM/8xCXdqmPK3+Q5Lug==", - "dev": true, - "requires": { - "@babel/core": "^7.11.6", - "@jest/types": "^29.3.1", - "@jridgewell/trace-mapping": "^0.3.15", - "babel-plugin-istanbul": "^6.1.1", - "chalk": "^4.0.0", - "convert-source-map": "^2.0.0", - "fast-json-stable-stringify": "^2.1.0", - "graceful-fs": "^4.2.9", - "jest-haste-map": "^29.3.1", - "jest-regex-util": "^29.2.0", - "jest-util": "^29.3.1", - "micromatch": "^4.0.4", - "pirates": "^4.0.4", - "slash": "^3.0.0", - "write-file-atomic": "^4.0.1" - } - }, - "@jest/types": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.3.1.tgz", - "integrity": "sha512-d0S0jmmTpjnhCmNpApgX3jrUZgZ22ivKJRvL2lli5hpCRoNnp1f85r2/wpKfXuYu8E7Jjh1hGfhPyup1NM5AmA==", - "dev": true, - "requires": { - "@jest/schemas": "^29.0.0", - "@types/istanbul-lib-coverage": "^2.0.0", - "@types/istanbul-reports": "^3.0.0", - "@types/node": "*", - "@types/yargs": "^17.0.8", - "chalk": "^4.0.0" - } - }, - "@jridgewell/gen-mapping": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz", - "integrity": "sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==", - "dev": true, - "requires": { - "@jridgewell/set-array": "^1.0.0", - "@jridgewell/sourcemap-codec": "^1.4.10" - } - }, - "@jridgewell/resolve-uri": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz", - "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==", - "dev": true - }, - "@jridgewell/set-array": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", - "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==", - "dev": true - }, - "@jridgewell/sourcemap-codec": { - "version": "1.4.14", - "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz", - "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==", - "dev": true - }, - "@jridgewell/trace-mapping": { - "version": "0.3.17", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.17.tgz", - "integrity": "sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g==", - "dev": true, - "requires": { - "@jridgewell/resolve-uri": "3.1.0", - "@jridgewell/sourcemap-codec": "1.4.14" - } - }, - "@microsoft/tsdoc": { - "version": "0.14.2", - "resolved": "https://registry.npmjs.org/@microsoft/tsdoc/-/tsdoc-0.14.2.tgz", - "integrity": "sha512-9b8mPpKrfeGRuhFH5iO1iwCLeIIsV6+H1sRfxbkoGXIyQE2BTsPd9zqSqQJ+pv5sJ/hT5M1zvOFL02MnEezFug==", - "dev": true - }, - "@microsoft/tsdoc-config": { - "version": "0.16.2", - "resolved": "https://registry.npmjs.org/@microsoft/tsdoc-config/-/tsdoc-config-0.16.2.tgz", - "integrity": "sha512-OGiIzzoBLgWWR0UdRJX98oYO+XKGf7tiK4Zk6tQ/E4IJqGCe7dvkTvgDZV5cFJUzLGDOjeAXrnZoA6QkVySuxw==", - "dev": true, - "requires": { - "@microsoft/tsdoc": "0.14.2", - "ajv": "~6.12.6", - "jju": "~1.4.0", - "resolve": "~1.19.0" - } - }, - "@nodelib/fs.scandir": { - "version": "2.1.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", - "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", - "dev": true, - "requires": { - "@nodelib/fs.stat": "2.0.5", - "run-parallel": "^1.1.9" - } - }, - "@nodelib/fs.stat": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", - "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", - "dev": true - }, - "@nodelib/fs.walk": { - "version": "1.2.8", - "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", - "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", - "dev": true, - "requires": { - "@nodelib/fs.scandir": "2.1.5", - "fastq": "^1.6.0" - } - }, - "@sinclair/typebox": { - "version": "0.24.51", - "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.24.51.tgz", - "integrity": "sha512-1P1OROm/rdubP5aFDSZQILU0vrLCJ4fvHt6EoqHEM+2D/G5MK3bIaymUKLit8Js9gbns5UyJnkP/TZROLw4tUA==", - "dev": true - }, - "@sinonjs/commons": { - "version": "1.8.6", - "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.6.tgz", - "integrity": "sha512-Ky+XkAkqPZSm3NLBeUng77EBQl3cmeJhITaGHdYH8kjVB+aun3S4XBRti2zt17mtt0mIUDiNxYeoJm6drVvBJQ==", - "dev": true, - "requires": { - "type-detect": "4.0.8" - } - }, - "@sinonjs/fake-timers": { - "version": "9.1.2", - "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-9.1.2.tgz", - "integrity": "sha512-BPS4ynJW/o92PUR4wgriz2Ud5gpST5vz6GQfMixEDK0Z8ZCUv2M7SkBLykH56T++Xs+8ln9zTGbOvNGIe02/jw==", - "dev": true, - "requires": { - "@sinonjs/commons": "^1.7.0" - } - }, - "@types/babel__core": { - "version": "7.1.20", - "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.1.20.tgz", - "integrity": "sha512-PVb6Bg2QuscZ30FvOU7z4guG6c926D9YRvOxEaelzndpMsvP+YM74Q/dAFASpg2l6+XLalxSGxcq/lrgYWZtyQ==", - "dev": true, - "requires": { - "@babel/parser": "^7.1.0", - "@babel/types": "^7.0.0", - "@types/babel__generator": "*", - "@types/babel__template": "*", - "@types/babel__traverse": "*" - } - }, - "@types/babel__generator": { - "version": "7.6.4", - "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.4.tgz", - "integrity": "sha512-tFkciB9j2K755yrTALxD44McOrk+gfpIpvC3sxHjRawj6PfnQxrse4Clq5y/Rq+G3mrBurMax/lG8Qn2t9mSsg==", - "dev": true, - "requires": { - "@babel/types": "^7.0.0" - } - }, - "@types/babel__template": { - "version": "7.4.1", - "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.1.tgz", - "integrity": "sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g==", - "dev": true, - "requires": { - "@babel/parser": "^7.1.0", - "@babel/types": "^7.0.0" - } - }, - "@types/babel__traverse": { - "version": "7.18.3", - "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.18.3.tgz", - "integrity": "sha512-1kbcJ40lLB7MHsj39U4Sh1uTd2E7rLEa79kmDpI6cy+XiXsteB3POdQomoq4FxszMrO3ZYchkhYJw7A2862b3w==", - "dev": true, - "requires": { - "@babel/types": "^7.3.0" - } - }, - "@types/bytebuffer": { - "version": "5.0.44", - "resolved": "https://registry.npmjs.org/@types/bytebuffer/-/bytebuffer-5.0.44.tgz", - "integrity": "sha512-k1qonHga/SfQT02NF633i+7tIfKd+cfC/8pjnedcfuXJNMWooss/FkCgRMSnLf2WorLjbuH4bfgAZEbtyHBDoQ==", - "dev": true, - "requires": { - "@types/long": "^3.0.0", - "@types/node": "*" - } - }, - "@types/debug": { - "version": "4.1.7", - "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.7.tgz", - "integrity": "sha512-9AonUzyTjXXhEOa0DnqpzZi6VHlqKMswga9EXjpXnnqxwLtdvPPtlO8evrI5D9S6asFRCQ6v+wpiUKbw+vKqyg==", - "dev": true, - "requires": { - "@types/ms": "*" - } - }, - "@types/graceful-fs": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.5.tgz", - "integrity": "sha512-anKkLmZZ+xm4p8JWBf4hElkM4XR+EZeA2M9BAkkTldmcyDY4mbdIJnRghDJH3Ov5ooY7/UAoENtmdMSkaAd7Cw==", - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "@types/ini": { - "version": "1.3.30", - "resolved": "https://registry.npmjs.org/@types/ini/-/ini-1.3.30.tgz", - "integrity": "sha512-2+iF8zPSbpU83UKE+PNd4r/MhwNAdyGpk3H+VMgEH3EhjFZq1kouLgRoZrmIcmoGX97xFvqdS44DkICR5Nz3tQ==", - "dev": true - }, - "@types/istanbul-lib-coverage": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.3.tgz", - "integrity": "sha512-sz7iLqvVUg1gIedBOvlkxPlc8/uVzyS5OwGz1cKjXzkl3FpL3al0crU8YGU1WoHkxn0Wxbw5tyi6hvzJKNzFsw==", - "dev": true - }, - "@types/istanbul-lib-report": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", - "integrity": "sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg==", - "dev": true, - "requires": { - "@types/istanbul-lib-coverage": "*" - } - }, - "@types/istanbul-reports": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.0.tgz", - "integrity": "sha512-nwKNbvnwJ2/mndE9ItP/zc2TCzw6uuodnF4EHYWD+gCQDVBuRQL5UzbZD0/ezy1iKsFU2ZQiDqg4M9dN4+wZgA==", - "dev": true, - "requires": { - "@types/istanbul-lib-report": "*" - } - }, - "@types/jest": { - "version": "29.2.4", - "resolved": "https://registry.npmjs.org/@types/jest/-/jest-29.2.4.tgz", - "integrity": "sha512-PipFB04k2qTRPePduVLTRiPzQfvMeLwUN3Z21hsAKaB/W9IIzgB2pizCL466ftJlcyZqnHoC9ZHpxLGl3fS86A==", - "dev": true, - "requires": { - "expect": "^29.0.0", - "pretty-format": "^29.0.0" - } - }, - "@types/json-schema": { - "version": "7.0.11", - "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz", - "integrity": "sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==", - "dev": true - }, - "@types/json5": { - "version": "0.0.29", - "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz", - "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==", - "dev": true - }, - "@types/long": { - "version": "3.0.32", - "resolved": "https://registry.npmjs.org/@types/long/-/long-3.0.32.tgz", - "integrity": "sha512-ZXyOOm83p7X8p3s0IYM3VeueNmHpkk/yMlP8CLeOnEcu6hIwPH7YjZBvhQkR0ZFS2DqZAxKtJ/M5fcuv3OU5BA==", - "dev": true - }, - "@types/minimatch": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.3.tgz", - "integrity": "sha512-tHq6qdbT9U1IRSGf14CL0pUlULksvY9OZ+5eEgl1N7t+OA3tGvNpxJCzuKQlsNgCVwbAs670L1vcVQi8j9HjnA==", - "dev": true - }, - "@types/ms": { - "version": "0.7.31", - "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.31.tgz", - "integrity": "sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA==", - "dev": true - }, - "@types/node": { - "version": "16.18.10", - "resolved": "https://registry.npmjs.org/@types/node/-/node-16.18.10.tgz", - "integrity": "sha512-XU1+v7h81p7145ddPfjv7jtWvkSilpcnON3mQ+bDi9Yuf7OI56efOglXRyXWgQ57xH3fEQgh7WOJMncRHVew5w==" - }, - "@types/prettier": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.1.tgz", - "integrity": "sha512-ri0UmynRRvZiiUJdiz38MmIblKK+oH30MztdBVR95dv/Ubw6neWSb8u1XpRb72L4qsZOhz+L+z9JD40SJmfWow==", - "dev": true - }, - "@types/stack-utils": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.1.tgz", - "integrity": "sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==", - "dev": true - }, - "@types/yargs": { - "version": "17.0.17", - "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.17.tgz", - "integrity": "sha512-72bWxFKTK6uwWJAVT+3rF6Jo6RTojiJ27FQo8Rf60AL+VZbzoVPnMFhKsUnbjR8A3BTCYQ7Mv3hnl8T0A+CX9g==", - "dev": true, - "requires": { - "@types/yargs-parser": "*" - } - }, - "@types/yargs-parser": { - "version": "21.0.0", - "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.0.tgz", - "integrity": "sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA==", - "dev": true - }, - "@typescript-eslint/eslint-plugin": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.26.0.tgz", - "integrity": "sha512-oGCmo0PqnRZZndr+KwvvAUvD3kNE4AfyoGCwOZpoCncSh4MVD06JTE8XQa2u9u+NX5CsyZMBTEc2C72zx38eYA==", - "dev": true, - "requires": { - "@typescript-eslint/scope-manager": "5.26.0", - "@typescript-eslint/type-utils": "5.26.0", - "@typescript-eslint/utils": "5.26.0", - "debug": "^4.3.4", - "functional-red-black-tree": "^1.0.1", - "ignore": "^5.2.0", - "regexpp": "^3.2.0", - "semver": "^7.3.7", - "tsutils": "^3.21.0" - }, - "dependencies": { - "semver": { - "version": "7.3.7", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz", - "integrity": "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==", - "dev": true, - "requires": { - "lru-cache": "^6.0.0" - } - } - } - }, - "@typescript-eslint/parser": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.26.0.tgz", - "integrity": "sha512-n/IzU87ttzIdnAH5vQ4BBDnLPly7rC5VnjN3m0xBG82HK6rhRxnCb3w/GyWbNDghPd+NktJqB/wl6+YkzZ5T5Q==", - "dev": true, - "requires": { - "@typescript-eslint/scope-manager": "5.26.0", - "@typescript-eslint/types": "5.26.0", - "@typescript-eslint/typescript-estree": "5.26.0", - "debug": "^4.3.4" - } - }, - "@typescript-eslint/scope-manager": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.26.0.tgz", - "integrity": "sha512-gVzTJUESuTwiju/7NiTb4c5oqod8xt5GhMbExKsCTp6adU3mya6AGJ4Pl9xC7x2DX9UYFsjImC0mA62BCY22Iw==", - "dev": true, - "requires": { - "@typescript-eslint/types": "5.26.0", - "@typescript-eslint/visitor-keys": "5.26.0" - } - }, - "@typescript-eslint/type-utils": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.26.0.tgz", - "integrity": "sha512-7ccbUVWGLmcRDSA1+ADkDBl5fP87EJt0fnijsMFTVHXKGduYMgienC/i3QwoVhDADUAPoytgjbZbCOMj4TY55A==", - "dev": true, - "requires": { - "@typescript-eslint/utils": "5.26.0", - "debug": "^4.3.4", - "tsutils": "^3.21.0" - } - }, - "@typescript-eslint/types": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.26.0.tgz", - "integrity": "sha512-8794JZFE1RN4XaExLWLI2oSXsVImNkl79PzTOOWt9h0UHROwJedNOD2IJyfL0NbddFllcktGIO2aOu10avQQyA==", - "dev": true - }, - "@typescript-eslint/typescript-estree": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.26.0.tgz", - "integrity": "sha512-EyGpw6eQDsfD6jIqmXP3rU5oHScZ51tL/cZgFbFBvWuCwrIptl+oueUZzSmLtxFuSOQ9vDcJIs+279gnJkfd1w==", - "dev": true, - "requires": { - "@typescript-eslint/types": "5.26.0", - "@typescript-eslint/visitor-keys": "5.26.0", - "debug": "^4.3.4", - "globby": "^11.1.0", - "is-glob": "^4.0.3", - "semver": "^7.3.7", - "tsutils": "^3.21.0" - }, - "dependencies": { - "semver": { - "version": "7.3.7", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz", - "integrity": "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==", - "dev": true, - "requires": { - "lru-cache": "^6.0.0" - } - } - } - }, - "@typescript-eslint/utils": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.26.0.tgz", - "integrity": "sha512-PJFwcTq2Pt4AMOKfe3zQOdez6InIDOjUJJD3v3LyEtxHGVVRK3Vo7Dd923t/4M9hSH2q2CLvcTdxlLPjcIk3eg==", - "dev": true, - "requires": { - "@types/json-schema": "^7.0.9", - "@typescript-eslint/scope-manager": "5.26.0", - "@typescript-eslint/types": "5.26.0", - "@typescript-eslint/typescript-estree": "5.26.0", - "eslint-scope": "^5.1.1", - "eslint-utils": "^3.0.0" - }, - "dependencies": { - "eslint-scope": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", - "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", - "dev": true, - "requires": { - "esrecurse": "^4.3.0", - "estraverse": "^4.1.1" - } - } - } - }, - "@typescript-eslint/visitor-keys": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.26.0.tgz", - "integrity": "sha512-wei+ffqHanYDOQgg/fS6Hcar6wAWv0CUPQ3TZzOWd2BLfgP539rb49bwua8WRAs7R6kOSLn82rfEu2ro6Llt8Q==", - "dev": true, - "requires": { - "@typescript-eslint/types": "5.26.0", - "eslint-visitor-keys": "^3.3.0" - } - }, - "acorn": { - "version": "7.4.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz", - "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==", - "dev": true, - "peer": true - }, - "acorn-jsx": { - "version": "5.3.2", - "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", - "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", - "dev": true, - "requires": {} - }, - "aggregate-error": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", - "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", - "dev": true, - "requires": { - "clean-stack": "^2.0.0", - "indent-string": "^4.0.0" - } - }, - "ajv": { - "version": "6.12.6", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", - "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", - "dev": true, - "requires": { - "fast-deep-equal": "^3.1.1", - "fast-json-stable-stringify": "^2.0.0", - "json-schema-traverse": "^0.4.1", - "uri-js": "^4.2.2" - } - }, - "ansi-escapes": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.1.tgz", - "integrity": "sha512-JWF7ocqNrp8u9oqpgV+wH5ftbt+cfvv+PTjOvKLT3AdYly/LmORARfEVT1iyjwN+4MqE5UmVKoAdIBqeoCHgLA==", - "dev": true, - "requires": { - "type-fest": "^0.11.0" - }, - "dependencies": { - "type-fest": { - "version": "0.11.0", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.11.0.tgz", - "integrity": "sha512-OdjXJxnCN1AvyLSzeKIgXTXxV+99ZuXl3Hpo9XpJAv9MBcHrrJOQ5kV7ypXOuQie+AmWG25hLbiKdwYTifzcfQ==", - "dev": true - } - } - }, - "ansi-regex": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", - "dev": true - }, - "ansi-sequence-parser": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/ansi-sequence-parser/-/ansi-sequence-parser-1.1.1.tgz", - "integrity": "sha512-vJXt3yiaUL4UU546s3rPXlsry/RnM730G1+HkpKE012AN0sx1eOrxSu95oKDIonskeLTijMgqWZ3uDEe3NFvyg==", - "dev": true - }, - "ansi-styles": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", - "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", - "dev": true, - "requires": { - "color-convert": "^2.0.1" - } - }, - "anymatch": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", - "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", - "dev": true, - "requires": { - "normalize-path": "^3.0.0", - "picomatch": "^2.0.4" - } - }, - "argparse": { - "version": "1.0.10", - "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", - "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", - "dev": true, - "requires": { - "sprintf-js": "~1.0.2" - } - }, - "array-differ": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/array-differ/-/array-differ-3.0.0.tgz", - "integrity": "sha512-THtfYS6KtME/yIAhKjZ2ul7XI96lQGHRputJQHO80LAWQnuGP4iCIN8vdMRboGbIEYBwU33q8Tch1os2+X0kMg==", - "dev": true - }, - "array-includes": { - "version": "3.1.5", - "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.5.tgz", - "integrity": "sha512-iSDYZMMyTPkiFasVqfuAQnWAYcvO/SeBSCGKePoEthjp4LEMTe4uLc7b025o4jAZpHhihh8xPo99TNWUWWkGDQ==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "es-abstract": "^1.19.5", - "get-intrinsic": "^1.1.1", - "is-string": "^1.0.7" - } - }, - "array-union": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", - "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", - "dev": true - }, - "array.prototype.flat": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.0.tgz", - "integrity": "sha512-12IUEkHsAhA4DY5s0FPgNXIdc8VRSqD9Zp78a5au9abH/SOBrsp082JOWFNTjkMozh8mqcdiKuaLGhPeYztxSw==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "es-abstract": "^1.19.2", - "es-shim-unscopables": "^1.0.0" - } - }, - "arrify": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/arrify/-/arrify-2.0.1.tgz", - "integrity": "sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==", - "dev": true - }, - "astral-regex": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz", - "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==", - "dev": true - }, - "babel-jest": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-29.3.1.tgz", - "integrity": "sha512-aard+xnMoxgjwV70t0L6wkW/3HQQtV+O0PEimxKgzNqCJnbYmroPojdP2tqKSOAt8QAKV/uSZU8851M7B5+fcA==", - "dev": true, - "requires": { - "@jest/transform": "^29.3.1", - "@types/babel__core": "^7.1.14", - "babel-plugin-istanbul": "^6.1.1", - "babel-preset-jest": "^29.2.0", - "chalk": "^4.0.0", - "graceful-fs": "^4.2.9", - "slash": "^3.0.0" - } - }, - "babel-plugin-istanbul": { - "version": "6.1.1", - "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz", - "integrity": "sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==", - "dev": true, - "requires": { - "@babel/helper-plugin-utils": "^7.0.0", - "@istanbuljs/load-nyc-config": "^1.0.0", - "@istanbuljs/schema": "^0.1.2", - "istanbul-lib-instrument": "^5.0.4", - "test-exclude": "^6.0.0" - } - }, - "babel-plugin-jest-hoist": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.2.0.tgz", - "integrity": "sha512-TnspP2WNiR3GLfCsUNHqeXw0RoQ2f9U5hQ5L3XFpwuO8htQmSrhh8qsB6vi5Yi8+kuynN1yjDjQsPfkebmB6ZA==", - "dev": true, - "requires": { - "@babel/template": "^7.3.3", - "@babel/types": "^7.3.3", - "@types/babel__core": "^7.1.14", - "@types/babel__traverse": "^7.0.6" - } - }, - "babel-preset-current-node-syntax": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz", - "integrity": "sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==", - "dev": true, - "requires": { - "@babel/plugin-syntax-async-generators": "^7.8.4", - "@babel/plugin-syntax-bigint": "^7.8.3", - "@babel/plugin-syntax-class-properties": "^7.8.3", - "@babel/plugin-syntax-import-meta": "^7.8.3", - "@babel/plugin-syntax-json-strings": "^7.8.3", - "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3", - "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", - "@babel/plugin-syntax-numeric-separator": "^7.8.3", - "@babel/plugin-syntax-object-rest-spread": "^7.8.3", - "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", - "@babel/plugin-syntax-optional-chaining": "^7.8.3", - "@babel/plugin-syntax-top-level-await": "^7.8.3" - } - }, - "babel-preset-jest": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-29.2.0.tgz", - "integrity": "sha512-z9JmMJppMxNv8N7fNRHvhMg9cvIkMxQBXgFkane3yKVEvEOP+kB50lk8DFRvF9PGqbyXxlmebKWhuDORO8RgdA==", - "dev": true, - "requires": { - "babel-plugin-jest-hoist": "^29.2.0", - "babel-preset-current-node-syntax": "^1.0.0" - } - }, - "balanced-match": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", - "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=", - "dev": true - }, - "brace-expansion": { - "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", - "dev": true, - "requires": { - "balanced-match": "^1.0.0", - "concat-map": "0.0.1" - } - }, - "braces": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", - "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", - "dev": true, - "requires": { - "fill-range": "^7.0.1" - } - }, - "browserslist": { - "version": "4.21.4", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.4.tgz", - "integrity": "sha512-CBHJJdDmgjl3daYjN5Cp5kbTf1mUhZoS+beLklHIvkOWscs83YAhLlF3Wsh/lciQYAcbBJgTOD44VtG31ZM4Hw==", - "dev": true, - "requires": { - "caniuse-lite": "^1.0.30001400", - "electron-to-chromium": "^1.4.251", - "node-releases": "^2.0.6", - "update-browserslist-db": "^1.0.9" - } - }, - "bs-logger": { - "version": "0.2.6", - "resolved": "https://registry.npmjs.org/bs-logger/-/bs-logger-0.2.6.tgz", - "integrity": "sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==", - "dev": true, - "requires": { - "fast-json-stable-stringify": "2.x" - } - }, - "bser": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz", - "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==", - "dev": true, - "requires": { - "node-int64": "^0.4.0" - } - }, - "buffer-from": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz", - "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==", - "dev": true - }, - "bytebuffer": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/bytebuffer/-/bytebuffer-5.0.1.tgz", - "integrity": "sha1-WC7qSxqHO20CCkjVjfhfC7ps/d0=", - "requires": { - "long": "~3" - } - }, - "call-bind": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", - "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", - "dev": true, - "requires": { - "function-bind": "^1.1.1", - "get-intrinsic": "^1.0.2" - } - }, - "callsites": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", - "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", - "dev": true - }, - "camelcase": { - "version": "5.3.1", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", - "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", - "dev": true - }, - "caniuse-lite": { - "version": "1.0.30001439", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001439.tgz", - "integrity": "sha512-1MgUzEkoMO6gKfXflStpYgZDlFM7M/ck/bgfVCACO5vnAf0fXoNVHdWtqGU+MYca+4bL9Z5bpOVmR33cWW9G2A==", - "dev": true - }, - "chalk": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz", - "integrity": "sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==", - "dev": true, - "requires": { - "ansi-styles": "^4.1.0", - "supports-color": "^7.1.0" - } - }, - "char-regex": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", - "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", - "dev": true - }, - "ci-info": { - "version": "3.7.0", - "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.7.0.tgz", - "integrity": "sha512-2CpRNYmImPx+RXKLq6jko/L07phmS9I02TyqkcNU20GCF/GgaWvc58hPtjxDX8lPpkdwc9sNh72V9k00S7ezog==", - "dev": true - }, - "cjs-module-lexer": { - "version": "1.2.2", - "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.2.2.tgz", - "integrity": "sha512-cOU9usZw8/dXIXKtwa8pM0OTJQuJkxMN6w30csNRUerHfeQ5R6U3kkU/FtJeIf3M202OHfY2U8ccInBG7/xogA==", - "dev": true - }, - "clean-stack": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", - "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==", - "dev": true - }, - "cli-cursor": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz", - "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==", - "dev": true, - "requires": { - "restore-cursor": "^3.1.0" - } - }, - "cli-truncate": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-3.1.0.tgz", - "integrity": "sha512-wfOBkjXteqSnI59oPcJkcPl/ZmwvMMOj340qUIY1SKZCv0B9Cf4D4fAucRkIKQmsIuYK3x1rrgU7MeGRruiuiA==", - "dev": true, - "requires": { - "slice-ansi": "^5.0.0", - "string-width": "^5.0.0" - }, - "dependencies": { - "ansi-regex": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", - "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==", - "dev": true - }, - "emoji-regex": { - "version": "9.2.2", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", - "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", - "dev": true - }, - "string-width": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", - "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", - "dev": true, - "requires": { - "eastasianwidth": "^0.2.0", - "emoji-regex": "^9.2.2", - "strip-ansi": "^7.0.1" - } - }, - "strip-ansi": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.0.1.tgz", - "integrity": "sha512-cXNxvT8dFNRVfhVME3JAe98mkXDYN2O1l7jmcwMnOslDeESg1rF/OZMtK0nRAhiari1unG5cD4jG3rapUAkLbw==", - "dev": true, - "requires": { - "ansi-regex": "^6.0.1" - } - } - } - }, - "cliui": { - "version": "8.0.1", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", - "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", - "dev": true, - "requires": { - "string-width": "^4.2.0", - "strip-ansi": "^6.0.1", - "wrap-ansi": "^7.0.0" - }, - "dependencies": { - "wrap-ansi": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", - "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", - "dev": true, - "requires": { - "ansi-styles": "^4.0.0", - "string-width": "^4.1.0", - "strip-ansi": "^6.0.0" - } - } - } - }, - "co": { - "version": "4.6.0", - "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", - "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==", - "dev": true - }, - "collect-v8-coverage": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz", - "integrity": "sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg==", - "dev": true - }, - "color-convert": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", - "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", - "dev": true, - "requires": { - "color-name": "~1.1.4" - } - }, - "color-name": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", - "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", - "dev": true - }, - "colorette": { - "version": "2.0.16", - "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.16.tgz", - "integrity": "sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==", - "dev": true - }, - "commander": { - "version": "8.3.0", - "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz", - "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==", - "dev": true - }, - "concat-map": { - "version": "0.0.1", - "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", - "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=", - "dev": true - }, - "confusing-browser-globals": { - "version": "1.0.11", - "resolved": "https://registry.npmjs.org/confusing-browser-globals/-/confusing-browser-globals-1.0.11.tgz", - "integrity": "sha512-JsPKdmh8ZkmnHxDk55FZ1TqVLvEQTvoByJZRN9jzI0UjxK/QgAmsphz7PGtqgPieQZ/CQcHWXCR7ATDNhGe+YA==", - "dev": true - }, - "convert-source-map": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", - "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", - "dev": true - }, - "core-util-is": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", - "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" - }, - "cross-spawn": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", - "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", - "dev": true, - "requires": { - "path-key": "^3.1.0", - "shebang-command": "^2.0.0", - "which": "^2.0.1" - } - }, - "debug": { - "version": "4.3.4", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", - "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", - "requires": { - "ms": "2.1.2" - } - }, - "dedent": { - "version": "0.7.0", - "resolved": "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz", - "integrity": "sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA==", - "dev": true - }, - "deep-is": { - "version": "0.1.3", - "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", - "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", - "dev": true - }, - "deepmerge": { - "version": "4.2.2", - "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz", - "integrity": "sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==", - "dev": true - }, - "define-properties": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.4.tgz", - "integrity": "sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA==", - "dev": true, - "requires": { - "has-property-descriptors": "^1.0.0", - "object-keys": "^1.1.1" - } - }, - "detect-newline": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", - "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", - "dev": true - }, - "dir-glob": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", - "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", - "dev": true, - "requires": { - "path-type": "^4.0.0" - } - }, - "doctrine": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", - "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", - "dev": true, - "requires": { - "esutils": "^2.0.2" - } - }, - "eastasianwidth": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", - "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", - "dev": true - }, - "electron-to-chromium": { - "version": "1.4.284", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.284.tgz", - "integrity": "sha512-M8WEXFuKXMYMVr45fo8mq0wUrrJHheiKZf6BArTKk9ZBYCKJEOU5H8cdWgDT+qCVZf7Na4lVUaZsA+h6uA9+PA==", - "dev": true - }, - "emittery": { - "version": "0.13.1", - "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.13.1.tgz", - "integrity": "sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==", - "dev": true - }, - "emoji-regex": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true - }, - "end-of-stream": { - "version": "1.4.4", - "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", - "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", - "dev": true, - "requires": { - "once": "^1.4.0" - } - }, - "error-ex": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", - "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", - "dev": true, - "requires": { - "is-arrayish": "^0.2.1" - } - }, - "es-abstract": { - "version": "1.20.1", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.20.1.tgz", - "integrity": "sha512-WEm2oBhfoI2sImeM4OF2zE2V3BYdSF+KnSi9Sidz51fQHd7+JuF8Xgcj9/0o+OWeIeIS/MiuNnlruQrJf16GQA==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "es-to-primitive": "^1.2.1", - "function-bind": "^1.1.1", - "function.prototype.name": "^1.1.5", - "get-intrinsic": "^1.1.1", - "get-symbol-description": "^1.0.0", - "has": "^1.0.3", - "has-property-descriptors": "^1.0.0", - "has-symbols": "^1.0.3", - "internal-slot": "^1.0.3", - "is-callable": "^1.2.4", - "is-negative-zero": "^2.0.2", - "is-regex": "^1.1.4", - "is-shared-array-buffer": "^1.0.2", - "is-string": "^1.0.7", - "is-weakref": "^1.0.2", - "object-inspect": "^1.12.0", - "object-keys": "^1.1.1", - "object.assign": "^4.1.2", - "regexp.prototype.flags": "^1.4.3", - "string.prototype.trimend": "^1.0.5", - "string.prototype.trimstart": "^1.0.5", - "unbox-primitive": "^1.0.2" - } - }, - "es-shim-unscopables": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz", - "integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==", - "dev": true, - "requires": { - "has": "^1.0.3" - } - }, - "es-to-primitive": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", - "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", - "dev": true, - "requires": { - "is-callable": "^1.1.4", - "is-date-object": "^1.0.1", - "is-symbol": "^1.0.2" - } - }, - "escalade": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", - "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", - "dev": true - }, - "escape-string-regexp": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", - "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", - "dev": true - }, - "eslint": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.16.0.tgz", - "integrity": "sha512-MBndsoXY/PeVTDJeWsYj7kLZ5hQpJOfMYLsF6LicLHQWbRDG19lK5jOix4DPl8yY4SUFcE3txy86OzFLWT+yoA==", - "dev": true, - "requires": { - "@eslint/eslintrc": "^1.3.0", - "@humanwhocodes/config-array": "^0.9.2", - "ajv": "^6.10.0", - "chalk": "^4.0.0", - "cross-spawn": "^7.0.2", - "debug": "^4.3.2", - "doctrine": "^3.0.0", - "escape-string-regexp": "^4.0.0", - "eslint-scope": "^7.1.1", - "eslint-utils": "^3.0.0", - "eslint-visitor-keys": "^3.3.0", - "espree": "^9.3.2", - "esquery": "^1.4.0", - "esutils": "^2.0.2", - "fast-deep-equal": "^3.1.3", - "file-entry-cache": "^6.0.1", - "functional-red-black-tree": "^1.0.1", - "glob-parent": "^6.0.1", - "globals": "^13.15.0", - "ignore": "^5.2.0", - "import-fresh": "^3.0.0", - "imurmurhash": "^0.1.4", - "is-glob": "^4.0.0", - "js-yaml": "^4.1.0", - "json-stable-stringify-without-jsonify": "^1.0.1", - "levn": "^0.4.1", - "lodash.merge": "^4.6.2", - "minimatch": "^3.1.2", - "natural-compare": "^1.4.0", - "optionator": "^0.9.1", - "regexpp": "^3.2.0", - "strip-ansi": "^6.0.1", - "strip-json-comments": "^3.1.0", - "text-table": "^0.2.0", - "v8-compile-cache": "^2.0.3" - }, - "dependencies": { - "argparse": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", - "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", - "dev": true - }, - "escape-string-regexp": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", - "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", - "dev": true - }, - "globals": { - "version": "13.15.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.15.0.tgz", - "integrity": "sha512-bpzcOlgDhMG070Av0Vy5Owklpv1I6+j96GhUI7Rh7IzDCKLzboflLrrfqMu8NquDbiR4EOQk7XzJwqVJxicxog==", - "dev": true, - "requires": { - "type-fest": "^0.20.2" - } - }, - "js-yaml": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", - "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", - "dev": true, - "requires": { - "argparse": "^2.0.1" - } - }, - "levn": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", - "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", - "dev": true, - "requires": { - "prelude-ls": "^1.2.1", - "type-check": "~0.4.0" - } - }, - "optionator": { - "version": "0.9.1", - "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz", - "integrity": "sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==", - "dev": true, - "requires": { - "deep-is": "^0.1.3", - "fast-levenshtein": "^2.0.6", - "levn": "^0.4.1", - "prelude-ls": "^1.2.1", - "type-check": "^0.4.0", - "word-wrap": "^1.2.3" - } - }, - "prelude-ls": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", - "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", - "dev": true - }, - "type-check": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", - "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", - "dev": true, - "requires": { - "prelude-ls": "^1.2.1" - } - }, - "type-fest": { - "version": "0.20.2", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", - "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", - "dev": true - } - } - }, - "eslint-config-airbnb-base": { - "version": "15.0.0", - "resolved": "https://registry.npmjs.org/eslint-config-airbnb-base/-/eslint-config-airbnb-base-15.0.0.tgz", - "integrity": "sha512-xaX3z4ZZIcFLvh2oUNvcX5oEofXda7giYmuplVxoOg5A7EXJMrUyqRgR+mhDhPK8LZ4PttFOBvCYDbX3sUoUig==", - "dev": true, - "requires": { - "confusing-browser-globals": "^1.0.10", - "object.assign": "^4.1.2", - "object.entries": "^1.1.5", - "semver": "^6.3.0" - } - }, - "eslint-config-airbnb-typescript": { - "version": "17.0.0", - "resolved": "https://registry.npmjs.org/eslint-config-airbnb-typescript/-/eslint-config-airbnb-typescript-17.0.0.tgz", - "integrity": "sha512-elNiuzD0kPAPTXjFWg+lE24nMdHMtuxgYoD30OyMD6yrW1AhFZPAg27VX7d3tzOErw+dgJTNWfRSDqEcXb4V0g==", - "dev": true, - "requires": { - "eslint-config-airbnb-base": "^15.0.0" - } - }, - "eslint-config-prettier": { - "version": "8.5.0", - "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-8.5.0.tgz", - "integrity": "sha512-obmWKLUNCnhtQRKc+tmnYuQl0pFU1ibYJQ5BGhTVB08bHe9wC8qUeG7c08dj9XX+AuPj1YSGSQIHl1pnDHZR0Q==", - "dev": true, - "requires": {} - }, - "eslint-import-resolver-node": { - "version": "0.3.6", - "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.6.tgz", - "integrity": "sha512-0En0w03NRVMn9Uiyn8YRPDKvWjxCWkslUEhGNTdGx15RvPJYQ+lbOlqrlNI2vEAs4pDYK4f/HN2TbDmk5TP0iw==", - "dev": true, - "requires": { - "debug": "^3.2.7", - "resolve": "^1.20.0" - }, - "dependencies": { - "debug": { - "version": "3.2.7", - "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", - "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", - "dev": true, - "requires": { - "ms": "^2.1.1" - } - }, - "resolve": { - "version": "1.22.0", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.0.tgz", - "integrity": "sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==", - "dev": true, - "requires": { - "is-core-module": "^2.8.1", - "path-parse": "^1.0.7", - "supports-preserve-symlinks-flag": "^1.0.0" - } - } - } - }, - "eslint-module-utils": { - "version": "2.7.3", - "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.7.3.tgz", - "integrity": "sha512-088JEC7O3lDZM9xGe0RerkOMd0EjFl+Yvd1jPWIkMT5u3H9+HC34mWWPnqPrN13gieT9pBOO+Qt07Nb/6TresQ==", - "dev": true, - "requires": { - "debug": "^3.2.7", - "find-up": "^2.1.0" - }, - "dependencies": { - "debug": { - "version": "3.2.7", - "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", - "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", - "dev": true, - "requires": { - "ms": "^2.1.1" - } - }, - "find-up": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", - "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", - "dev": true, - "requires": { - "locate-path": "^2.0.0" - } - }, - "locate-path": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", - "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", - "dev": true, - "requires": { - "p-locate": "^2.0.0", - "path-exists": "^3.0.0" - } - }, - "p-limit": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz", - "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==", - "dev": true, - "requires": { - "p-try": "^1.0.0" - } - }, - "p-locate": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", - "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", - "dev": true, - "requires": { - "p-limit": "^1.1.0" - } - }, - "p-try": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", - "integrity": "sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=", - "dev": true - }, - "path-exists": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", - "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", - "dev": true - } - } - }, - "eslint-plugin-import": { - "version": "2.26.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.26.0.tgz", - "integrity": "sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA==", - "dev": true, - "requires": { - "array-includes": "^3.1.4", - "array.prototype.flat": "^1.2.5", - "debug": "^2.6.9", - "doctrine": "^2.1.0", - "eslint-import-resolver-node": "^0.3.6", - "eslint-module-utils": "^2.7.3", - "has": "^1.0.3", - "is-core-module": "^2.8.1", - "is-glob": "^4.0.3", - "minimatch": "^3.1.2", - "object.values": "^1.1.5", - "resolve": "^1.22.0", - "tsconfig-paths": "^3.14.1" - }, - "dependencies": { - "debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", - "dev": true, - "requires": { - "ms": "2.0.0" - } - }, - "doctrine": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", - "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", - "dev": true, - "requires": { - "esutils": "^2.0.2" - } - }, - "ms": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", - "dev": true - }, - "resolve": { - "version": "1.22.0", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.0.tgz", - "integrity": "sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==", - "dev": true, - "requires": { - "is-core-module": "^2.8.1", - "path-parse": "^1.0.7", - "supports-preserve-symlinks-flag": "^1.0.0" - } - } - } - }, - "eslint-plugin-prettier": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-4.0.0.tgz", - "integrity": "sha512-98MqmCJ7vJodoQK359bqQWaxOE0CS8paAz/GgjaZLyex4TTk3g9HugoO89EqWCrFiOqn9EVvcoo7gZzONCWVwQ==", - "dev": true, - "requires": { - "prettier-linter-helpers": "^1.0.0" - } - }, - "eslint-plugin-simple-import-sort": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-simple-import-sort/-/eslint-plugin-simple-import-sort-7.0.0.tgz", - "integrity": "sha512-U3vEDB5zhYPNfxT5TYR7u01dboFZp+HNpnGhkDB2g/2E4wZ/g1Q9Ton8UwCLfRV9yAKyYqDh62oHOamvkFxsvw==", - "dev": true, - "requires": {} - }, - "eslint-plugin-tsdoc": { - "version": "0.2.17", - "resolved": "https://registry.npmjs.org/eslint-plugin-tsdoc/-/eslint-plugin-tsdoc-0.2.17.tgz", - "integrity": "sha512-xRmVi7Zx44lOBuYqG8vzTXuL6IdGOeF9nHX17bjJ8+VE6fsxpdGem0/SBTmAwgYMKYB1WBkqRJVQ+n8GK041pA==", - "dev": true, - "requires": { - "@microsoft/tsdoc": "0.14.2", - "@microsoft/tsdoc-config": "0.16.2" - } - }, - "eslint-scope": { - "version": "7.1.1", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz", - "integrity": "sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==", - "dev": true, - "requires": { - "esrecurse": "^4.3.0", - "estraverse": "^5.2.0" - }, - "dependencies": { - "estraverse": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", - "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", - "dev": true - } - } - }, - "eslint-utils": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-3.0.0.tgz", - "integrity": "sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==", - "dev": true, - "requires": { - "eslint-visitor-keys": "^2.0.0" - }, - "dependencies": { - "eslint-visitor-keys": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz", - "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==", - "dev": true - } - } - }, - "eslint-visitor-keys": { - "version": "3.3.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz", - "integrity": "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==", - "dev": true - }, - "espree": { - "version": "9.3.2", - "resolved": "https://registry.npmjs.org/espree/-/espree-9.3.2.tgz", - "integrity": "sha512-D211tC7ZwouTIuY5x9XnS0E9sWNChB7IYKX/Xp5eQj3nFXhqmiUDB9q27y76oFl8jTg3pXcQx/bpxMfs3CIZbA==", - "dev": true, - "requires": { - "acorn": "^8.7.1", - "acorn-jsx": "^5.3.2", - "eslint-visitor-keys": "^3.3.0" - }, - "dependencies": { - "acorn": { - "version": "8.7.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz", - "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==", - "dev": true - } - } - }, - "esprima": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", - "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", - "dev": true - }, - "esquery": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.4.0.tgz", - "integrity": "sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==", - "dev": true, - "requires": { - "estraverse": "^5.1.0" - }, - "dependencies": { - "estraverse": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", - "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", - "dev": true - } - } - }, - "esrecurse": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", - "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", - "dev": true, - "requires": { - "estraverse": "^5.2.0" - }, - "dependencies": { - "estraverse": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", - "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", - "dev": true - } - } - }, - "estraverse": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", - "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", - "dev": true - }, - "esutils": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", - "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", - "dev": true - }, - "execa": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", - "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==", - "dev": true, - "requires": { - "cross-spawn": "^7.0.3", - "get-stream": "^6.0.0", - "human-signals": "^2.1.0", - "is-stream": "^2.0.0", - "merge-stream": "^2.0.0", - "npm-run-path": "^4.0.1", - "onetime": "^5.1.2", - "signal-exit": "^3.0.3", - "strip-final-newline": "^2.0.0" - }, - "dependencies": { - "human-signals": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", - "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", - "dev": true - } - } - }, - "exit": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", - "integrity": "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==", - "dev": true - }, - "expect": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/expect/-/expect-29.3.1.tgz", - "integrity": "sha512-gGb1yTgU30Q0O/tQq+z30KBWv24ApkMgFUpvKBkyLUBL68Wv8dHdJxTBZFl/iT8K/bqDHvUYRH6IIN3rToopPA==", - "dev": true, - "requires": { - "@jest/expect-utils": "^29.3.1", - "jest-get-type": "^29.2.0", - "jest-matcher-utils": "^29.3.1", - "jest-message-util": "^29.3.1", - "jest-util": "^29.3.1" - }, - "dependencies": { - "jest-get-type": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", - "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", - "dev": true - } - } - }, - "fast-deep-equal": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", - "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", - "dev": true - }, - "fast-diff": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.2.0.tgz", - "integrity": "sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w==", - "dev": true - }, - "fast-glob": { - "version": "3.2.11", - "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.11.tgz", - "integrity": "sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew==", - "dev": true, - "requires": { - "@nodelib/fs.stat": "^2.0.2", - "@nodelib/fs.walk": "^1.2.3", - "glob-parent": "^5.1.2", - "merge2": "^1.3.0", - "micromatch": "^4.0.4" - }, - "dependencies": { - "glob-parent": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", - "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", - "dev": true, - "requires": { - "is-glob": "^4.0.1" - } - } - } - }, - "fast-json-stable-stringify": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", - "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", - "dev": true - }, - "fast-levenshtein": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", - "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", - "dev": true - }, - "fastq": { - "version": "1.13.0", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.13.0.tgz", - "integrity": "sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==", - "dev": true, - "requires": { - "reusify": "^1.0.4" - } - }, - "fb-watchman": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz", - "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==", - "dev": true, - "requires": { - "bser": "2.1.1" - } - }, - "file-entry-cache": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", - "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", - "dev": true, - "requires": { - "flat-cache": "^3.0.4" - } - }, - "fill-range": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", - "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", - "dev": true, - "requires": { - "to-regex-range": "^5.0.1" - } - }, - "find-up": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", - "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", - "dev": true, - "requires": { - "locate-path": "^5.0.0", - "path-exists": "^4.0.0" - } - }, - "flat-cache": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz", - "integrity": "sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==", - "dev": true, - "requires": { - "flatted": "^3.1.0", - "rimraf": "^3.0.2" - } - }, - "flatted": { - "version": "3.2.5", - "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.5.tgz", - "integrity": "sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==", - "dev": true - }, - "fs.realpath": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", - "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", - "dev": true - }, - "fsevents": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", - "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", - "dev": true, - "optional": true - }, - "function-bind": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", - "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", - "dev": true - }, - "function.prototype.name": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", - "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "es-abstract": "^1.19.0", - "functions-have-names": "^1.2.2" - } - }, - "functional-red-black-tree": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", - "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", - "dev": true - }, - "functions-have-names": { - "version": "1.2.3", - "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", - "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", - "dev": true - }, - "gensync": { - "version": "1.0.0-beta.2", - "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", - "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", - "dev": true - }, - "get-caller-file": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", - "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", - "dev": true - }, - "get-intrinsic": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz", - "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==", - "dev": true, - "requires": { - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-symbols": "^1.0.1" - } - }, - "get-package-type": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", - "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", - "dev": true - }, - "get-stream": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", - "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", - "dev": true - }, - "get-symbol-description": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", - "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.1.1" - } - }, - "glob": { - "version": "7.1.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", - "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", - "dev": true, - "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - } - }, - "glob-parent": { - "version": "6.0.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", - "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", - "dev": true, - "requires": { - "is-glob": "^4.0.3" - } - }, - "globals": { - "version": "11.12.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", - "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", - "dev": true - }, - "globby": { - "version": "11.1.0", - "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", - "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", - "dev": true, - "requires": { - "array-union": "^2.1.0", - "dir-glob": "^3.0.1", - "fast-glob": "^3.2.9", - "ignore": "^5.2.0", - "merge2": "^1.4.1", - "slash": "^3.0.0" - } - }, - "graceful-fs": { - "version": "4.2.10", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", - "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", - "dev": true - }, - "has": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", - "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", - "dev": true, - "requires": { - "function-bind": "^1.1.1" - } - }, - "has-bigints": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", - "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", - "dev": true - }, - "has-flag": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", - "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", - "dev": true - }, - "has-property-descriptors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", - "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", - "dev": true, - "requires": { - "get-intrinsic": "^1.1.1" - } - }, - "has-symbols": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", - "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", - "dev": true - }, - "has-tostringtag": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", - "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", - "dev": true, - "requires": { - "has-symbols": "^1.0.2" - } - }, - "hasown": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.0.tgz", - "integrity": "sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==", - "dev": true, - "requires": { - "function-bind": "^1.1.2" - } - }, - "html-escaper": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", - "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", - "dev": true - }, - "human-signals": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-1.1.1.tgz", - "integrity": "sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==", - "dev": true - }, - "husky": { - "version": "8.0.1", - "resolved": "https://registry.npmjs.org/husky/-/husky-8.0.1.tgz", - "integrity": "sha512-xs7/chUH/CKdOCs7Zy0Aev9e/dKOMZf3K1Az1nar3tzlv0jfqnYtu235bstsWTmXOR0EfINrPa97yy4Lz6RiKw==", - "dev": true - }, - "if-async": { - "version": "3.7.4", - "resolved": "https://registry.npmjs.org/if-async/-/if-async-3.7.4.tgz", - "integrity": "sha1-VYaN6wCT08Z79xZudFNT+5vLIaI=" - }, - "ignore": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.0.tgz", - "integrity": "sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==", - "dev": true - }, - "import-fresh": { - "version": "3.3.0", - "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", - "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", - "dev": true, - "requires": { - "parent-module": "^1.0.0", - "resolve-from": "^4.0.0" - }, - "dependencies": { - "resolve-from": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", - "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", - "dev": true - } - } - }, - "import-local": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz", - "integrity": "sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==", - "dev": true, - "requires": { - "pkg-dir": "^4.2.0", - "resolve-cwd": "^3.0.0" - } - }, - "imurmurhash": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", - "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", - "dev": true - }, - "indent-string": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", - "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", - "dev": true - }, - "inflight": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", - "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", - "dev": true, - "requires": { - "once": "^1.3.0", - "wrappy": "1" - } - }, - "inherits": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" - }, - "ini": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ini/-/ini-2.0.0.tgz", - "integrity": "sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==" - }, - "internal-slot": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.3.tgz", - "integrity": "sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA==", - "dev": true, - "requires": { - "get-intrinsic": "^1.1.0", - "has": "^1.0.3", - "side-channel": "^1.0.4" - } - }, - "is-arrayish": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", - "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", - "dev": true - }, - "is-bigint": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", - "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", - "dev": true, - "requires": { - "has-bigints": "^1.0.1" - } - }, - "is-boolean-object": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", - "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "has-tostringtag": "^1.0.0" - } - }, - "is-callable": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.4.tgz", - "integrity": "sha512-nsuwtxZfMX67Oryl9LCQ+upnC0Z0BgpwntpS89m1H/TLF0zNfzfLMV/9Wa/6MZsj0acpEjAO0KF1xT6ZdLl95w==", - "dev": true - }, - "is-core-module": { - "version": "2.13.1", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.13.1.tgz", - "integrity": "sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==", - "dev": true, - "requires": { - "hasown": "^2.0.0" - } - }, - "is-date-object": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", - "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", - "dev": true, - "requires": { - "has-tostringtag": "^1.0.0" - } - }, - "is-extglob": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", - "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", - "dev": true - }, - "is-fullwidth-code-point": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", - "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", - "dev": true - }, - "is-generator-fn": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz", - "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==", - "dev": true - }, - "is-glob": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", - "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", - "dev": true, - "requires": { - "is-extglob": "^2.1.1" - } - }, - "is-negative-zero": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", - "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", - "dev": true - }, - "is-number": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", - "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", - "dev": true - }, - "is-number-object": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", - "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", - "dev": true, - "requires": { - "has-tostringtag": "^1.0.0" - } - }, - "is-regex": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", - "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "has-tostringtag": "^1.0.0" - } - }, - "is-shared-array-buffer": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", - "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", - "dev": true, - "requires": { - "call-bind": "^1.0.2" - } - }, - "is-stream": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", - "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", - "dev": true - }, - "is-string": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", - "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", - "dev": true, - "requires": { - "has-tostringtag": "^1.0.0" - } - }, - "is-symbol": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", - "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", - "dev": true, - "requires": { - "has-symbols": "^1.0.2" - } - }, - "is-weakref": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", - "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", - "dev": true, - "requires": { - "call-bind": "^1.0.2" - } - }, - "isarray": { - "version": "0.0.1", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", - "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" - }, - "isexe": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", - "dev": true - }, - "istanbul-lib-coverage": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz", - "integrity": "sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==", - "dev": true - }, - "istanbul-lib-instrument": { - "version": "5.2.1", - "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz", - "integrity": "sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==", - "dev": true, - "requires": { - "@babel/core": "^7.12.3", - "@babel/parser": "^7.14.7", - "@istanbuljs/schema": "^0.1.2", - "istanbul-lib-coverage": "^3.2.0", - "semver": "^6.3.0" - } - }, - "istanbul-lib-report": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", - "integrity": "sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==", - "dev": true, - "requires": { - "istanbul-lib-coverage": "^3.0.0", - "make-dir": "^3.0.0", - "supports-color": "^7.1.0" - } - }, - "istanbul-lib-source-maps": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz", - "integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==", - "dev": true, - "requires": { - "debug": "^4.1.1", - "istanbul-lib-coverage": "^3.0.0", - "source-map": "^0.6.1" - } - }, - "istanbul-reports": { - "version": "3.1.5", - "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.5.tgz", - "integrity": "sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w==", - "dev": true, - "requires": { - "html-escaper": "^2.0.0", - "istanbul-lib-report": "^3.0.0" - } - }, - "jest": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest/-/jest-29.3.1.tgz", - "integrity": "sha512-6iWfL5DTT0Np6UYs/y5Niu7WIfNv/wRTtN5RSXt2DIEft3dx3zPuw/3WJQBCJfmEzvDiEKwoqMbGD9n49+qLSA==", - "dev": true, - "requires": { - "@jest/core": "^29.3.1", - "@jest/types": "^29.3.1", - "import-local": "^3.0.2", - "jest-cli": "^29.3.1" - } - }, - "jest-changed-files": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-29.2.0.tgz", - "integrity": "sha512-qPVmLLyBmvF5HJrY7krDisx6Voi8DmlV3GZYX0aFNbaQsZeoz1hfxcCMbqDGuQCxU1dJy9eYc2xscE8QrCCYaA==", - "dev": true, - "requires": { - "execa": "^5.0.0", - "p-limit": "^3.1.0" - }, - "dependencies": { - "p-limit": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", - "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", - "dev": true, - "requires": { - "yocto-queue": "^0.1.0" - } - } - } - }, - "jest-circus": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-29.3.1.tgz", - "integrity": "sha512-wpr26sEvwb3qQQbdlmei+gzp6yoSSoSL6GsLPxnuayZSMrSd5Ka7IjAvatpIernBvT2+Ic6RLTg+jSebScmasg==", - "dev": true, - "requires": { - "@jest/environment": "^29.3.1", - "@jest/expect": "^29.3.1", - "@jest/test-result": "^29.3.1", - "@jest/types": "^29.3.1", - "@types/node": "*", - "chalk": "^4.0.0", - "co": "^4.6.0", - "dedent": "^0.7.0", - "is-generator-fn": "^2.0.0", - "jest-each": "^29.3.1", - "jest-matcher-utils": "^29.3.1", - "jest-message-util": "^29.3.1", - "jest-runtime": "^29.3.1", - "jest-snapshot": "^29.3.1", - "jest-util": "^29.3.1", - "p-limit": "^3.1.0", - "pretty-format": "^29.3.1", - "slash": "^3.0.0", - "stack-utils": "^2.0.3" - }, - "dependencies": { - "p-limit": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", - "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", - "dev": true, - "requires": { - "yocto-queue": "^0.1.0" - } - } - } - }, - "jest-cli": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-29.3.1.tgz", - "integrity": "sha512-TO/ewvwyvPOiBBuWZ0gm04z3WWP8TIK8acgPzE4IxgsLKQgb377NYGrQLc3Wl/7ndWzIH2CDNNsUjGxwLL43VQ==", - "dev": true, - "requires": { - "@jest/core": "^29.3.1", - "@jest/test-result": "^29.3.1", - "@jest/types": "^29.3.1", - "chalk": "^4.0.0", - "exit": "^0.1.2", - "graceful-fs": "^4.2.9", - "import-local": "^3.0.2", - "jest-config": "^29.3.1", - "jest-util": "^29.3.1", - "jest-validate": "^29.3.1", - "prompts": "^2.0.1", - "yargs": "^17.3.1" - } - }, - "jest-config": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-29.3.1.tgz", - "integrity": "sha512-y0tFHdj2WnTEhxmGUK1T7fgLen7YK4RtfvpLFBXfQkh2eMJAQq24Vx9472lvn5wg0MAO6B+iPfJfzdR9hJYalg==", - "dev": true, - "requires": { - "@babel/core": "^7.11.6", - "@jest/test-sequencer": "^29.3.1", - "@jest/types": "^29.3.1", - "babel-jest": "^29.3.1", - "chalk": "^4.0.0", - "ci-info": "^3.2.0", - "deepmerge": "^4.2.2", - "glob": "^7.1.3", - "graceful-fs": "^4.2.9", - "jest-circus": "^29.3.1", - "jest-environment-node": "^29.3.1", - "jest-get-type": "^29.2.0", - "jest-regex-util": "^29.2.0", - "jest-resolve": "^29.3.1", - "jest-runner": "^29.3.1", - "jest-util": "^29.3.1", - "jest-validate": "^29.3.1", - "micromatch": "^4.0.4", - "parse-json": "^5.2.0", - "pretty-format": "^29.3.1", - "slash": "^3.0.0", - "strip-json-comments": "^3.1.1" - }, - "dependencies": { - "jest-get-type": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", - "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", - "dev": true - } - } - }, - "jest-docblock": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-29.2.0.tgz", - "integrity": "sha512-bkxUsxTgWQGbXV5IENmfiIuqZhJcyvF7tU4zJ/7ioTutdz4ToB5Yx6JOFBpgI+TphRY4lhOyCWGNH/QFQh5T6A==", - "dev": true, - "requires": { - "detect-newline": "^3.0.0" - } - }, - "jest-each": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-29.3.1.tgz", - "integrity": "sha512-qrZH7PmFB9rEzCSl00BWjZYuS1BSOH8lLuC0azQE9lQrAx3PWGKHTDudQiOSwIy5dGAJh7KA0ScYlCP7JxvFYA==", - "dev": true, - "requires": { - "@jest/types": "^29.3.1", - "chalk": "^4.0.0", - "jest-get-type": "^29.2.0", - "jest-util": "^29.3.1", - "pretty-format": "^29.3.1" - }, - "dependencies": { - "jest-get-type": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", - "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", - "dev": true - } - } - }, - "jest-environment-node": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-29.3.1.tgz", - "integrity": "sha512-xm2THL18Xf5sIHoU7OThBPtuH6Lerd+Y1NLYiZJlkE3hbE+7N7r8uvHIl/FkZ5ymKXJe/11SQuf3fv4v6rUMag==", - "dev": true, - "requires": { - "@jest/environment": "^29.3.1", - "@jest/fake-timers": "^29.3.1", - "@jest/types": "^29.3.1", - "@types/node": "*", - "jest-mock": "^29.3.1", - "jest-util": "^29.3.1" - } - }, - "jest-haste-map": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-29.3.1.tgz", - "integrity": "sha512-/FFtvoG1xjbbPXQLFef+WSU4yrc0fc0Dds6aRPBojUid7qlPqZvxdUBA03HW0fnVHXVCnCdkuoghYItKNzc/0A==", - "dev": true, - "requires": { - "@jest/types": "^29.3.1", - "@types/graceful-fs": "^4.1.3", - "@types/node": "*", - "anymatch": "^3.0.3", - "fb-watchman": "^2.0.0", - "fsevents": "^2.3.2", - "graceful-fs": "^4.2.9", - "jest-regex-util": "^29.2.0", - "jest-util": "^29.3.1", - "jest-worker": "^29.3.1", - "micromatch": "^4.0.4", - "walker": "^1.0.8" - } - }, - "jest-leak-detector": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-29.3.1.tgz", - "integrity": "sha512-3DA/VVXj4zFOPagGkuqHnSQf1GZBmmlagpguxEERO6Pla2g84Q1MaVIB3YMxgUaFIaYag8ZnTyQgiZ35YEqAQA==", - "dev": true, - "requires": { - "jest-get-type": "^29.2.0", - "pretty-format": "^29.3.1" - }, - "dependencies": { - "jest-get-type": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", - "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", - "dev": true - } - } - }, - "jest-matcher-utils": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-29.3.1.tgz", - "integrity": "sha512-fkRMZUAScup3txIKfMe3AIZZmPEjWEdsPJFK3AIy5qRohWqQFg1qrmKfYXR9qEkNc7OdAu2N4KPHibEmy4HPeQ==", - "dev": true, - "requires": { - "chalk": "^4.0.0", - "jest-diff": "^29.3.1", - "jest-get-type": "^29.2.0", - "pretty-format": "^29.3.1" - }, - "dependencies": { - "diff-sequences": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.3.1.tgz", - "integrity": "sha512-hlM3QR272NXCi4pq+N4Kok4kOp6EsgOM3ZSpJI7Da3UAs+Ttsi8MRmB6trM/lhyzUxGfOgnpkHtgqm5Q/CTcfQ==", - "dev": true - }, - "jest-diff": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-29.3.1.tgz", - "integrity": "sha512-vU8vyiO7568tmin2lA3r2DP8oRvzhvRcD4DjpXc6uGveQodyk7CKLhQlCSiwgx3g0pFaE88/KLZ0yaTWMc4Uiw==", - "dev": true, - "requires": { - "chalk": "^4.0.0", - "diff-sequences": "^29.3.1", - "jest-get-type": "^29.2.0", - "pretty-format": "^29.3.1" - } - }, - "jest-get-type": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", - "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", - "dev": true - } - } - }, - "jest-message-util": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-29.3.1.tgz", - "integrity": "sha512-lMJTbgNcDm5z+6KDxWtqOFWlGQxD6XaYwBqHR8kmpkP+WWWG90I35kdtQHY67Ay5CSuydkTBbJG+tH9JShFCyA==", - "dev": true, - "requires": { - "@babel/code-frame": "^7.12.13", - "@jest/types": "^29.3.1", - "@types/stack-utils": "^2.0.0", - "chalk": "^4.0.0", - "graceful-fs": "^4.2.9", - "micromatch": "^4.0.4", - "pretty-format": "^29.3.1", - "slash": "^3.0.0", - "stack-utils": "^2.0.3" - } - }, - "jest-mock": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-29.3.1.tgz", - "integrity": "sha512-H8/qFDtDVMFvFP4X8NuOT3XRDzOUTz+FeACjufHzsOIBAxivLqkB1PoLCaJx9iPPQ8dZThHPp/G3WRWyMgA3JA==", - "dev": true, - "requires": { - "@jest/types": "^29.3.1", - "@types/node": "*", - "jest-util": "^29.3.1" - } - }, - "jest-pnp-resolver": { - "version": "1.2.3", - "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz", - "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==", - "dev": true, - "requires": {} - }, - "jest-regex-util": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.2.0.tgz", - "integrity": "sha512-6yXn0kg2JXzH30cr2NlThF+70iuO/3irbaB4mh5WyqNIvLLP+B6sFdluO1/1RJmslyh/f9osnefECflHvTbwVA==", - "dev": true - }, - "jest-resolve": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-29.3.1.tgz", - "integrity": "sha512-amXJgH/Ng712w3Uz5gqzFBBjxV8WFLSmNjoreBGMqxgCz5cH7swmBZzgBaCIOsvb0NbpJ0vgaSFdJqMdT+rADw==", - "dev": true, - "requires": { - "chalk": "^4.0.0", - "graceful-fs": "^4.2.9", - "jest-haste-map": "^29.3.1", - "jest-pnp-resolver": "^1.2.2", - "jest-util": "^29.3.1", - "jest-validate": "^29.3.1", - "resolve": "^1.20.0", - "resolve.exports": "^1.1.0", - "slash": "^3.0.0" - }, - "dependencies": { - "resolve": { - "version": "1.22.1", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz", - "integrity": "sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==", - "dev": true, - "requires": { - "is-core-module": "^2.9.0", - "path-parse": "^1.0.7", - "supports-preserve-symlinks-flag": "^1.0.0" - } - } - } - }, - "jest-resolve-dependencies": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-29.3.1.tgz", - "integrity": "sha512-Vk0cYq0byRw2WluNmNWGqPeRnZ3p3hHmjJMp2dyyZeYIfiBskwq4rpiuGFR6QGAdbj58WC7HN4hQHjf2mpvrLA==", - "dev": true, - "requires": { - "jest-regex-util": "^29.2.0", - "jest-snapshot": "^29.3.1" - } - }, - "jest-runner": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-29.3.1.tgz", - "integrity": "sha512-oFvcwRNrKMtE6u9+AQPMATxFcTySyKfLhvso7Sdk/rNpbhg4g2GAGCopiInk1OP4q6gz3n6MajW4+fnHWlU3bA==", - "dev": true, - "requires": { - "@jest/console": "^29.3.1", - "@jest/environment": "^29.3.1", - "@jest/test-result": "^29.3.1", - "@jest/transform": "^29.3.1", - "@jest/types": "^29.3.1", - "@types/node": "*", - "chalk": "^4.0.0", - "emittery": "^0.13.1", - "graceful-fs": "^4.2.9", - "jest-docblock": "^29.2.0", - "jest-environment-node": "^29.3.1", - "jest-haste-map": "^29.3.1", - "jest-leak-detector": "^29.3.1", - "jest-message-util": "^29.3.1", - "jest-resolve": "^29.3.1", - "jest-runtime": "^29.3.1", - "jest-util": "^29.3.1", - "jest-watcher": "^29.3.1", - "jest-worker": "^29.3.1", - "p-limit": "^3.1.0", - "source-map-support": "0.5.13" - }, - "dependencies": { - "p-limit": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", - "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", - "dev": true, - "requires": { - "yocto-queue": "^0.1.0" - } - } - } - }, - "jest-runtime": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-29.3.1.tgz", - "integrity": "sha512-jLzkIxIqXwBEOZx7wx9OO9sxoZmgT2NhmQKzHQm1xwR1kNW/dn0OjxR424VwHHf1SPN6Qwlb5pp1oGCeFTQ62A==", - "dev": true, - "requires": { - "@jest/environment": "^29.3.1", - "@jest/fake-timers": "^29.3.1", - "@jest/globals": "^29.3.1", - "@jest/source-map": "^29.2.0", - "@jest/test-result": "^29.3.1", - "@jest/transform": "^29.3.1", - "@jest/types": "^29.3.1", - "@types/node": "*", - "chalk": "^4.0.0", - "cjs-module-lexer": "^1.0.0", - "collect-v8-coverage": "^1.0.0", - "glob": "^7.1.3", - "graceful-fs": "^4.2.9", - "jest-haste-map": "^29.3.1", - "jest-message-util": "^29.3.1", - "jest-mock": "^29.3.1", - "jest-regex-util": "^29.2.0", - "jest-resolve": "^29.3.1", - "jest-snapshot": "^29.3.1", - "jest-util": "^29.3.1", - "slash": "^3.0.0", - "strip-bom": "^4.0.0" - } - }, - "jest-snapshot": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-29.3.1.tgz", - "integrity": "sha512-+3JOc+s28upYLI2OJM4PWRGK9AgpsMs/ekNryUV0yMBClT9B1DF2u2qay8YxcQd338PPYSFNb0lsar1B49sLDA==", - "dev": true, - "requires": { - "@babel/core": "^7.11.6", - "@babel/generator": "^7.7.2", - "@babel/plugin-syntax-jsx": "^7.7.2", - "@babel/plugin-syntax-typescript": "^7.7.2", - "@babel/traverse": "^7.7.2", - "@babel/types": "^7.3.3", - "@jest/expect-utils": "^29.3.1", - "@jest/transform": "^29.3.1", - "@jest/types": "^29.3.1", - "@types/babel__traverse": "^7.0.6", - "@types/prettier": "^2.1.5", - "babel-preset-current-node-syntax": "^1.0.0", - "chalk": "^4.0.0", - "expect": "^29.3.1", - "graceful-fs": "^4.2.9", - "jest-diff": "^29.3.1", - "jest-get-type": "^29.2.0", - "jest-haste-map": "^29.3.1", - "jest-matcher-utils": "^29.3.1", - "jest-message-util": "^29.3.1", - "jest-util": "^29.3.1", - "natural-compare": "^1.4.0", - "pretty-format": "^29.3.1", - "semver": "^7.3.5" - }, - "dependencies": { - "diff-sequences": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.3.1.tgz", - "integrity": "sha512-hlM3QR272NXCi4pq+N4Kok4kOp6EsgOM3ZSpJI7Da3UAs+Ttsi8MRmB6trM/lhyzUxGfOgnpkHtgqm5Q/CTcfQ==", - "dev": true - }, - "jest-diff": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-29.3.1.tgz", - "integrity": "sha512-vU8vyiO7568tmin2lA3r2DP8oRvzhvRcD4DjpXc6uGveQodyk7CKLhQlCSiwgx3g0pFaE88/KLZ0yaTWMc4Uiw==", - "dev": true, - "requires": { - "chalk": "^4.0.0", - "diff-sequences": "^29.3.1", - "jest-get-type": "^29.2.0", - "pretty-format": "^29.3.1" - } - }, - "jest-get-type": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", - "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", - "dev": true - }, - "semver": { - "version": "7.3.8", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.8.tgz", - "integrity": "sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==", - "dev": true, - "requires": { - "lru-cache": "^6.0.0" - } - } - } - }, - "jest-util": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.3.1.tgz", - "integrity": "sha512-7YOVZaiX7RJLv76ZfHt4nbNEzzTRiMW/IiOG7ZOKmTXmoGBxUDefgMAxQubu6WPVqP5zSzAdZG0FfLcC7HOIFQ==", - "dev": true, - "requires": { - "@jest/types": "^29.3.1", - "@types/node": "*", - "chalk": "^4.0.0", - "ci-info": "^3.2.0", - "graceful-fs": "^4.2.9", - "picomatch": "^2.2.3" - } - }, - "jest-validate": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-29.3.1.tgz", - "integrity": "sha512-N9Lr3oYR2Mpzuelp1F8negJR3YE+L1ebk1rYA5qYo9TTY3f9OWdptLoNSPP9itOCBIRBqjt/S5XHlzYglLN67g==", - "dev": true, - "requires": { - "@jest/types": "^29.3.1", - "camelcase": "^6.2.0", - "chalk": "^4.0.0", - "jest-get-type": "^29.2.0", - "leven": "^3.1.0", - "pretty-format": "^29.3.1" - }, - "dependencies": { - "camelcase": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", - "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", - "dev": true - }, - "jest-get-type": { - "version": "29.2.0", - "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", - "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", - "dev": true - } - } - }, - "jest-watcher": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-29.3.1.tgz", - "integrity": "sha512-RspXG2BQFDsZSRKGCT/NiNa8RkQ1iKAjrO0//soTMWx/QUt+OcxMqMSBxz23PYGqUuWm2+m2mNNsmj0eIoOaFg==", - "dev": true, - "requires": { - "@jest/test-result": "^29.3.1", - "@jest/types": "^29.3.1", - "@types/node": "*", - "ansi-escapes": "^4.2.1", - "chalk": "^4.0.0", - "emittery": "^0.13.1", - "jest-util": "^29.3.1", - "string-length": "^4.0.1" - } - }, - "jest-worker": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-29.3.1.tgz", - "integrity": "sha512-lY4AnnmsEWeiXirAIA0c9SDPbuCBq8IYuDVL8PMm0MZ2PEs2yPvRA/J64QBXuZp7CYKrDM/rmNrc9/i3KJQncw==", - "dev": true, - "requires": { - "@types/node": "*", - "jest-util": "^29.3.1", - "merge-stream": "^2.0.0", - "supports-color": "^8.0.0" - }, - "dependencies": { - "supports-color": { - "version": "8.1.1", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", - "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", - "dev": true, - "requires": { - "has-flag": "^4.0.0" - } - } - } - }, - "jju": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/jju/-/jju-1.4.0.tgz", - "integrity": "sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==", - "dev": true - }, - "js-tokens": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", - "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", - "dev": true - }, - "js-yaml": { - "version": "3.14.1", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", - "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", - "dev": true, - "requires": { - "argparse": "^1.0.7", - "esprima": "^4.0.0" - } - }, - "jsesc": { - "version": "2.5.2", - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", - "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", - "dev": true - }, - "json-parse-even-better-errors": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", - "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", - "dev": true - }, - "json-schema-traverse": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", - "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", - "dev": true - }, - "json-stable-stringify-without-jsonify": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", - "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", - "dev": true - }, - "json5": { - "version": "2.2.2", - "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.2.tgz", - "integrity": "sha512-46Tk9JiOL2z7ytNQWFLpj99RZkVgeHf87yGQKsIkaPz1qSH9UczKH1rO7K3wgRselo0tYMUNfecYpm/p1vC7tQ==", - "dev": true - }, - "jsonc-parser": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz", - "integrity": "sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==", - "dev": true - }, - "kleur": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz", - "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", - "dev": true - }, - "leven": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", - "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", - "dev": true - }, - "lilconfig": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.0.4.tgz", - "integrity": "sha512-bfTIN7lEsiooCocSISTWXkiWJkRqtL9wYtYy+8EK3Y41qh3mpwPU0ycTOgjdY9ErwXCc8QyrQp82bdL0Xkm9yA==", - "dev": true - }, - "lines-and-columns": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", - "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", - "dev": true - }, - "lint-staged": { - "version": "12.4.2", - "resolved": "https://registry.npmjs.org/lint-staged/-/lint-staged-12.4.2.tgz", - "integrity": "sha512-JAJGIzY/OioIUtrRePr8go6qUxij//mL+RGGoFKU3VWQRtIHgWoHizSqH0QVn2OwrbXS9Q6CICQjfj+E5qvrXg==", - "dev": true, - "requires": { - "cli-truncate": "^3.1.0", - "colorette": "^2.0.16", - "commander": "^8.3.0", - "debug": "^4.3.3", - "execa": "^5.1.1", - "lilconfig": "2.0.4", - "listr2": "^4.0.1", - "micromatch": "^4.0.4", - "normalize-path": "^3.0.0", - "object-inspect": "^1.12.0", - "pidtree": "^0.5.0", - "string-argv": "^0.3.1", - "supports-color": "^9.2.1", - "yaml": "^1.10.2" - }, - "dependencies": { - "supports-color": { - "version": "9.2.2", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-9.2.2.tgz", - "integrity": "sha512-XC6g/Kgux+rJXmwokjm9ECpD6k/smUoS5LKlUCcsYr4IY3rW0XyAympon2RmxGrlnZURMpg5T18gWDP9CsHXFA==", - "dev": true - } - } - }, - "listr2": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/listr2/-/listr2-4.0.5.tgz", - "integrity": "sha512-juGHV1doQdpNT3GSTs9IUN43QJb7KHdF9uqg7Vufs/tG9VTzpFphqF4pm/ICdAABGQxsyNn9CiYA3StkI6jpwA==", - "dev": true, - "requires": { - "cli-truncate": "^2.1.0", - "colorette": "^2.0.16", - "log-update": "^4.0.0", - "p-map": "^4.0.0", - "rfdc": "^1.3.0", - "rxjs": "^7.5.5", - "through": "^2.3.8", - "wrap-ansi": "^7.0.0" - }, - "dependencies": { - "cli-truncate": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-2.1.0.tgz", - "integrity": "sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==", - "dev": true, - "requires": { - "slice-ansi": "^3.0.0", - "string-width": "^4.2.0" - } - }, - "slice-ansi": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz", - "integrity": "sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==", - "dev": true, - "requires": { - "ansi-styles": "^4.0.0", - "astral-regex": "^2.0.0", - "is-fullwidth-code-point": "^3.0.0" - } - }, - "wrap-ansi": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", - "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", - "dev": true, - "requires": { - "ansi-styles": "^4.0.0", - "string-width": "^4.1.0", - "strip-ansi": "^6.0.0" - } - } - } - }, - "locate-path": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", - "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", - "dev": true, - "requires": { - "p-locate": "^4.1.0" - } - }, - "lodash.memoize": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", - "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==", - "dev": true - }, - "lodash.merge": { - "version": "4.6.2", - "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", - "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", - "dev": true - }, - "log-update": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/log-update/-/log-update-4.0.0.tgz", - "integrity": "sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg==", - "dev": true, - "requires": { - "ansi-escapes": "^4.3.0", - "cli-cursor": "^3.1.0", - "slice-ansi": "^4.0.0", - "wrap-ansi": "^6.2.0" - }, - "dependencies": { - "slice-ansi": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz", - "integrity": "sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==", - "dev": true, - "requires": { - "ansi-styles": "^4.0.0", - "astral-regex": "^2.0.0", - "is-fullwidth-code-point": "^3.0.0" - } - } - } - }, - "long": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/long/-/long-3.2.0.tgz", - "integrity": "sha1-2CG3E4yhy1gcFymQ7xTbIAtcR0s=" - }, - "lru-cache": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", - "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", - "dev": true, - "requires": { - "yallist": "^4.0.0" - } - }, - "lunr": { - "version": "2.3.9", - "resolved": "https://registry.npmjs.org/lunr/-/lunr-2.3.9.tgz", - "integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==", - "dev": true - }, - "make-dir": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", - "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==", - "dev": true, - "requires": { - "semver": "^6.0.0" - } - }, - "make-error": { - "version": "1.3.6", - "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", - "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", - "dev": true - }, - "makeerror": { - "version": "1.0.12", - "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz", - "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==", - "dev": true, - "requires": { - "tmpl": "1.0.5" - } - }, - "marked": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/marked/-/marked-4.3.0.tgz", - "integrity": "sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==", - "dev": true - }, - "merge-stream": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", - "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", - "dev": true - }, - "merge2": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", - "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", - "dev": true - }, - "micromatch": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", - "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", - "dev": true, - "requires": { - "braces": "^3.0.2", - "picomatch": "^2.3.1" - } - }, - "mimic-fn": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", - "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", - "dev": true - }, - "minimatch": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", - "dev": true, - "requires": { - "brace-expansion": "^1.1.7" - } - }, - "minimist": { - "version": "1.2.6", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz", - "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==", - "dev": true - }, - "mri": { - "version": "1.1.6", - "resolved": "https://registry.npmjs.org/mri/-/mri-1.1.6.tgz", - "integrity": "sha512-oi1b3MfbyGa7FJMP9GmLTttni5JoICpYBRlq+x5V16fZbLsnL9N3wFqqIm/nIG43FjUFkFh9Epzp/kzUGUnJxQ==", - "dev": true - }, - "ms": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" - }, - "multimatch": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/multimatch/-/multimatch-4.0.0.tgz", - "integrity": "sha512-lDmx79y1z6i7RNx0ZGCPq1bzJ6ZoDDKbvh7jxr9SJcWLkShMzXrHbYVpTdnhNM5MXpDUxCQ4DgqVttVXlBgiBQ==", - "dev": true, - "requires": { - "@types/minimatch": "^3.0.3", - "array-differ": "^3.0.0", - "array-union": "^2.1.0", - "arrify": "^2.0.1", - "minimatch": "^3.0.4" - } - }, - "natural-compare": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", - "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=", - "dev": true - }, - "node-int64": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz", - "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==", - "dev": true - }, - "node-releases": { - "version": "2.0.7", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.7.tgz", - "integrity": "sha512-EJ3rzxL9pTWPjk5arA0s0dgXpnyiAbJDE6wHT62g7VsgrgQgmmZ+Ru++M1BFofncWja+Pnn3rEr3fieRySAdKQ==", - "dev": true - }, - "normalize-path": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", - "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", - "dev": true - }, - "npm-run-path": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", - "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", - "dev": true, - "requires": { - "path-key": "^3.0.0" - } - }, - "object-inspect": { - "version": "1.12.2", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.2.tgz", - "integrity": "sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ==", - "dev": true - }, - "object-keys": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", - "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", - "dev": true - }, - "object.assign": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz", - "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==", - "dev": true, - "requires": { - "call-bind": "^1.0.0", - "define-properties": "^1.1.3", - "has-symbols": "^1.0.1", - "object-keys": "^1.1.1" - } - }, - "object.entries": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.5.tgz", - "integrity": "sha512-TyxmjUoZggd4OrrU1W66FMDG6CuqJxsFvymeyXI51+vQLN67zYfZseptRge703kKQdo4uccgAKebXFcRCzk4+g==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "es-abstract": "^1.19.1" - } - }, - "object.values": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.5.tgz", - "integrity": "sha512-QUZRW0ilQ3PnPpbNtgdNV1PDbEqLIiSFB3l+EnGtBQ/8SUTLj1PZwtQHABZtLgwpJZTSZhuGLOGk57Drx2IvYg==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "es-abstract": "^1.19.1" - } - }, - "once": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", - "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", - "dev": true, - "requires": { - "wrappy": "1" - } - }, - "onetime": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", - "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", - "dev": true, - "requires": { - "mimic-fn": "^2.1.0" - } - }, - "p-limit": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", - "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", - "dev": true, - "requires": { - "p-try": "^2.0.0" - } - }, - "p-locate": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", - "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", - "dev": true, - "requires": { - "p-limit": "^2.2.0" - } - }, - "p-map": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", - "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", - "dev": true, - "requires": { - "aggregate-error": "^3.0.0" - } - }, - "p-try": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", - "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", - "dev": true - }, - "parent-module": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", - "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", - "dev": true, - "requires": { - "callsites": "^3.0.0" - } - }, - "parse-json": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", - "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", - "dev": true, - "requires": { - "@babel/code-frame": "^7.0.0", - "error-ex": "^1.3.1", - "json-parse-even-better-errors": "^2.3.0", - "lines-and-columns": "^1.1.6" - } - }, - "path-exists": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", - "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", - "dev": true - }, - "path-is-absolute": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", - "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", - "dev": true - }, - "path-key": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", - "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", - "dev": true - }, - "path-parse": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", - "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", - "dev": true - }, - "path-type": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", - "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", - "dev": true - }, - "picocolors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", - "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==", - "dev": true - }, - "picomatch": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", - "dev": true - }, - "pidtree": { - "version": "0.5.0", - "resolved": "https://registry.npmjs.org/pidtree/-/pidtree-0.5.0.tgz", - "integrity": "sha512-9nxspIM7OpZuhBxPg73Zvyq7j1QMPMPsGKTqRc2XOaFQauDvoNz9fM1Wdkjmeo7l9GXOZiRs97sPkuayl39wjA==", - "dev": true - }, - "pirates": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.5.tgz", - "integrity": "sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==", - "dev": true - }, - "pkg-dir": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", - "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", - "dev": true, - "requires": { - "find-up": "^4.0.0" - } - }, - "prettier": { - "version": "2.6.2", - "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.6.2.tgz", - "integrity": "sha512-PkUpF+qoXTqhOeWL9fu7As8LXsIUZ1WYaJiY/a7McAQzxjk82OF0tibkFXVCDImZtWxbvojFjerkiLb0/q8mew==", - "dev": true - }, - "prettier-linter-helpers": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz", - "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==", - "dev": true, - "requires": { - "fast-diff": "^1.1.2" - } - }, - "pretty-format": { - "version": "29.3.1", - "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.3.1.tgz", - "integrity": "sha512-FyLnmb1cYJV8biEIiRyzRFvs2lry7PPIvOqKVe1GCUEYg4YGmlx1qG9EJNMxArYm7piII4qb8UV1Pncq5dxmcg==", - "dev": true, - "requires": { - "@jest/schemas": "^29.0.0", - "ansi-styles": "^5.0.0", - "react-is": "^18.0.0" - }, - "dependencies": { - "ansi-styles": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", - "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", - "dev": true - } - } - }, - "pretty-quick": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/pretty-quick/-/pretty-quick-3.1.0.tgz", - "integrity": "sha512-DtxIxksaUWCgPFN7E1ZZk4+Aav3CCuRdhrDSFZENb404sYMtuo9Zka823F+Mgeyt8Zt3bUiCjFzzWYE9LYqkmQ==", - "dev": true, - "requires": { - "chalk": "^3.0.0", - "execa": "^4.0.0", - "find-up": "^4.1.0", - "ignore": "^5.1.4", - "mri": "^1.1.5", - "multimatch": "^4.0.0" - }, - "dependencies": { - "chalk": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz", - "integrity": "sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==", - "dev": true, - "requires": { - "ansi-styles": "^4.1.0", - "supports-color": "^7.1.0" - } - }, - "execa": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/execa/-/execa-4.1.0.tgz", - "integrity": "sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==", - "dev": true, - "requires": { - "cross-spawn": "^7.0.0", - "get-stream": "^5.0.0", - "human-signals": "^1.1.1", - "is-stream": "^2.0.0", - "merge-stream": "^2.0.0", - "npm-run-path": "^4.0.0", - "onetime": "^5.1.0", - "signal-exit": "^3.0.2", - "strip-final-newline": "^2.0.0" - } - }, - "get-stream": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", - "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", - "dev": true, - "requires": { - "pump": "^3.0.0" - } - } - } - }, - "prompts": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", - "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==", - "dev": true, - "requires": { - "kleur": "^3.0.3", - "sisteransi": "^1.0.5" - } - }, - "pump": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz", - "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==", - "dev": true, - "requires": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, - "punycode": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", - "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==", - "dev": true - }, - "queue-microtask": { - "version": "1.2.3", - "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", - "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", - "dev": true - }, - "react-is": { - "version": "18.2.0", - "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz", - "integrity": "sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==", - "dev": true - }, - "readable-stream": { - "version": "1.0.34", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", - "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.1", - "isarray": "0.0.1", - "string_decoder": "~0.10.x" - } - }, - "regedit": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/regedit/-/regedit-5.1.1.tgz", - "integrity": "sha512-NJ2OZ14czryt3RiQyMM/nptaiu0bF1CT+YVw0PBziMrLJyq8pdmIAvupi9E+NPWJLDJtyHDoKs5g5wcbP8ANIg==", - "requires": { - "debug": "^4.1.0", - "if-async": "^3.7.4", - "stream-slicer": "0.0.6", - "through2": "^0.6.3" - } - }, - "regexp.prototype.flags": { - "version": "1.4.3", - "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz", - "integrity": "sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "functions-have-names": "^1.2.2" - } - }, - "regexpp": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz", - "integrity": "sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==", - "dev": true - }, - "require-directory": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", - "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", - "dev": true - }, - "resolve": { - "version": "1.19.0", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.19.0.tgz", - "integrity": "sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==", - "dev": true, - "requires": { - "is-core-module": "^2.1.0", - "path-parse": "^1.0.6" - } - }, - "resolve-cwd": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", - "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", - "dev": true, - "requires": { - "resolve-from": "^5.0.0" - } - }, - "resolve-from": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", - "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", - "dev": true - }, - "resolve.exports": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-1.1.0.tgz", - "integrity": "sha512-J1l+Zxxp4XK3LUDZ9m60LRJF/mAe4z6a4xyabPHk7pvK5t35dACV32iIjJDFeWZFfZlO29w6SZ67knR0tHzJtQ==", - "dev": true - }, - "restore-cursor": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz", - "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==", - "dev": true, - "requires": { - "onetime": "^5.1.0", - "signal-exit": "^3.0.2" - } - }, - "reusify": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", - "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", - "dev": true - }, - "rfdc": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.3.0.tgz", - "integrity": "sha512-V2hovdzFbOi77/WajaSMXk2OLm+xNIeQdMMuB7icj7bk6zi2F8GGAxigcnDFpJHbNyNcgyJDiP+8nOrY5cZGrA==", - "dev": true - }, - "rimraf": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", - "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", - "dev": true, - "requires": { - "glob": "^7.1.3" - } - }, - "run-parallel": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", - "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", - "dev": true, - "requires": { - "queue-microtask": "^1.2.2" - } - }, - "rxjs": { - "version": "7.5.5", - "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.5.5.tgz", - "integrity": "sha512-sy+H0pQofO95VDmFLzyaw9xNJU4KTRSwQIGM6+iG3SypAtCiLDzpeG8sJrNCWn2Up9km+KhkvTdbkrdy+yzZdw==", - "dev": true, - "requires": { - "tslib": "^2.1.0" - }, - "dependencies": { - "tslib": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz", - "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==", - "dev": true - } - } - }, - "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", - "dev": true - }, - "shebang-command": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", - "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", - "dev": true, - "requires": { - "shebang-regex": "^3.0.0" - } - }, - "shebang-regex": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", - "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", - "dev": true - }, - "shiki": { - "version": "0.14.7", - "resolved": "https://registry.npmjs.org/shiki/-/shiki-0.14.7.tgz", - "integrity": "sha512-dNPAPrxSc87ua2sKJ3H5dQ/6ZaY8RNnaAqK+t0eG7p0Soi2ydiqbGOTaZCqaYvA/uZYfS1LJnemt3Q+mSfcPCg==", - "dev": true, - "requires": { - "ansi-sequence-parser": "^1.1.0", - "jsonc-parser": "^3.2.0", - "vscode-oniguruma": "^1.7.0", - "vscode-textmate": "^8.0.0" - } - }, - "side-channel": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", - "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", - "dev": true, - "requires": { - "call-bind": "^1.0.0", - "get-intrinsic": "^1.0.2", - "object-inspect": "^1.9.0" - } - }, - "signal-exit": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", - "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", - "dev": true - }, - "sisteransi": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", - "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==", - "dev": true - }, - "slash": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", - "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", - "dev": true - }, - "slice-ansi": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz", - "integrity": "sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==", - "dev": true, - "requires": { - "ansi-styles": "^6.0.0", - "is-fullwidth-code-point": "^4.0.0" - }, - "dependencies": { - "ansi-styles": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.1.0.tgz", - "integrity": "sha512-VbqNsoz55SYGczauuup0MFUyXNQviSpFTj1RQtFzmQLk18qbVSpTFFGMT293rmDaQuKCT6InmbuEyUne4mTuxQ==", - "dev": true - }, - "is-fullwidth-code-point": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz", - "integrity": "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==", - "dev": true - } - } - }, - "source-map": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", - "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", - "dev": true - }, - "source-map-support": { - "version": "0.5.13", - "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz", - "integrity": "sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==", - "dev": true, - "requires": { - "buffer-from": "^1.0.0", - "source-map": "^0.6.0" - } - }, - "sprintf-js": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", - "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", - "dev": true - }, - "stack-utils": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz", - "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==", - "dev": true, - "requires": { - "escape-string-regexp": "^2.0.0" - } - }, - "stream-slicer": { - "version": "0.0.6", - "resolved": "https://registry.npmjs.org/stream-slicer/-/stream-slicer-0.0.6.tgz", - "integrity": "sha1-+GsqxcJEC3oKh7cfM2ZcB4gEYTg=" - }, - "string_decoder": { - "version": "0.10.31", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", - "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" - }, - "string-argv": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/string-argv/-/string-argv-0.3.1.tgz", - "integrity": "sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg==", - "dev": true - }, - "string-length": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz", - "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==", - "dev": true, - "requires": { - "char-regex": "^1.0.2", - "strip-ansi": "^6.0.0" - } - }, - "string-width": { - "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", - "dev": true, - "requires": { - "emoji-regex": "^8.0.0", - "is-fullwidth-code-point": "^3.0.0", - "strip-ansi": "^6.0.1" - } - }, - "string.prototype.trimend": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.5.tgz", - "integrity": "sha512-I7RGvmjV4pJ7O3kdf+LXFpVfdNOxtCW/2C8f6jNiW4+PQchwxkCDzlk1/7p+Wl4bqFIZeF47qAHXLuHHWKAxog==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "es-abstract": "^1.19.5" - } - }, - "string.prototype.trimstart": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.5.tgz", - "integrity": "sha512-THx16TJCGlsN0o6dl2o6ncWUsdgnLRSA23rRE5pyGBw/mLr3Ej/R2LaqCtgP8VNMGZsvMWnf9ooZPyY2bHvUFg==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "es-abstract": "^1.19.5" - } - }, - "strip-ansi": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", - "dev": true, - "requires": { - "ansi-regex": "^5.0.1" - } - }, - "strip-bom": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", - "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", - "dev": true - }, - "strip-final-newline": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", - "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", - "dev": true - }, - "strip-json-comments": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", - "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", - "dev": true - }, - "supports-color": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", - "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", - "dev": true, - "requires": { - "has-flag": "^4.0.0" - } - }, - "supports-preserve-symlinks-flag": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", - "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", - "dev": true - }, - "test-exclude": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", - "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", - "dev": true, - "requires": { - "@istanbuljs/schema": "^0.1.2", - "glob": "^7.1.4", - "minimatch": "^3.0.4" - } - }, - "text-table": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", - "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=", - "dev": true - }, - "through": { - "version": "2.3.8", - "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", - "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=", - "dev": true - }, - "through2": { - "version": "0.6.5", - "resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz", - "integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=", - "requires": { - "readable-stream": ">=1.0.33-1 <1.1.0-0", - "xtend": ">=4.0.0 <4.1.0-0" - } - }, - "tmpl": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz", - "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==", - "dev": true - }, - "to-fast-properties": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", - "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", - "dev": true - }, - "to-regex-range": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", - "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", - "dev": true, - "requires": { - "is-number": "^7.0.0" - } - }, - "ts-jest": { - "version": "29.0.3", - "resolved": "https://registry.npmjs.org/ts-jest/-/ts-jest-29.0.3.tgz", - "integrity": "sha512-Ibygvmuyq1qp/z3yTh9QTwVVAbFdDy/+4BtIQR2sp6baF2SJU/8CKK/hhnGIDY2L90Az2jIqTwZPnN2p+BweiQ==", - "dev": true, - "requires": { - "bs-logger": "0.x", - "fast-json-stable-stringify": "2.x", - "jest-util": "^29.0.0", - "json5": "^2.2.1", - "lodash.memoize": "4.x", - "make-error": "1.x", - "semver": "7.x", - "yargs-parser": "^21.0.1" - }, - "dependencies": { - "semver": { - "version": "7.3.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.4.tgz", - "integrity": "sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==", - "dev": true, - "requires": { - "lru-cache": "^6.0.0" - } - } - } - }, - "tsconfig-paths": { - "version": "3.14.1", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.1.tgz", - "integrity": "sha512-fxDhWnFSLt3VuTwtvJt5fpwxBHg5AdKWMsgcPOOIilyjymcYVZoCQF8fvFRezCNfblEXmi+PcM1eYHeOAgXCOQ==", - "dev": true, - "requires": { - "@types/json5": "^0.0.29", - "json5": "^1.0.1", - "minimist": "^1.2.6", - "strip-bom": "^3.0.0" - }, - "dependencies": { - "json5": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", - "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", - "dev": true, - "requires": { - "minimist": "^1.2.0" - } - }, - "strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", - "dev": true - } - } - }, - "tslib": { - "version": "1.14.1", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", - "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", - "dev": true - }, - "tsutils": { - "version": "3.21.0", - "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz", - "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==", - "dev": true, - "requires": { - "tslib": "^1.8.1" - } - }, - "type-detect": { - "version": "4.0.8", - "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", - "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", - "dev": true - }, - "typedoc": { - "version": "0.25.4", - "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.25.4.tgz", - "integrity": "sha512-Du9ImmpBCw54bX275yJrxPVnjdIyJO/84co0/L9mwe0R3G4FSR6rQ09AlXVRvZEGMUg09+z/usc8mgygQ1aidA==", - "dev": true, - "requires": { - "lunr": "^2.3.9", - "marked": "^4.3.0", - "minimatch": "^9.0.3", - "shiki": "^0.14.1" - }, - "dependencies": { - "brace-expansion": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", - "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", - "dev": true, - "requires": { - "balanced-match": "^1.0.0" - } - }, - "minimatch": { - "version": "9.0.3", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", - "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", - "dev": true, - "requires": { - "brace-expansion": "^2.0.1" - } - } - } - }, - "typescript": { - "version": "4.9.4", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.4.tgz", - "integrity": "sha512-Uz+dTXYzxXXbsFpM86Wh3dKCxrQqUcVMxwU54orwlJjOpO3ao8L7j5lH+dWfTwgCwIuM9GQ2kvVotzYJMXTBZg==", - "dev": true - }, - "unbox-primitive": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", - "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", - "dev": true, - "requires": { - "call-bind": "^1.0.2", - "has-bigints": "^1.0.2", - "has-symbols": "^1.0.3", - "which-boxed-primitive": "^1.0.2" - } - }, - "update-browserslist-db": { - "version": "1.0.10", - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz", - "integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==", - "dev": true, - "requires": { - "escalade": "^3.1.1", - "picocolors": "^1.0.0" - } - }, - "uri-js": { - "version": "4.4.0", - "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.0.tgz", - "integrity": "sha512-B0yRTzYdUCCn9n+F4+Gh4yIDtMQcaJsmYBDsTSG8g/OejKBodLQ2IHfN3bM7jUsRXndopT7OIXWdYqc1fjmV6g==", - "dev": true, - "requires": { - "punycode": "^2.1.0" - } - }, - "v8-compile-cache": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz", - "integrity": "sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==", - "dev": true - }, - "v8-to-istanbul": { - "version": "9.0.1", - "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.0.1.tgz", - "integrity": "sha512-74Y4LqY74kLE6IFyIjPtkSTWzUZmj8tdHT9Ii/26dvQ6K9Dl2NbEfj0XgU2sHCtKgt5VupqhlO/5aWuqS+IY1w==", - "dev": true, - "requires": { - "@jridgewell/trace-mapping": "^0.3.12", - "@types/istanbul-lib-coverage": "^2.0.1", - "convert-source-map": "^1.6.0" - }, - "dependencies": { - "convert-source-map": { - "version": "1.9.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", - "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", - "dev": true - } - } - }, - "vscode-oniguruma": { - "version": "1.7.0", - "resolved": "https://registry.npmjs.org/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz", - "integrity": "sha512-L9WMGRfrjOhgHSdOYgCt/yRMsXzLDJSL7BPrOZt73gU0iWO4mpqzqQzOz5srxqTvMBaR0XZTSrVWo4j55Rc6cA==", - "dev": true - }, - "vscode-textmate": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/vscode-textmate/-/vscode-textmate-8.0.0.tgz", - "integrity": "sha512-AFbieoL7a5LMqcnOF04ji+rpXadgOXnZsxQr//r83kLPr7biP7am3g9zbaZIaBGwBRWeSvoMD4mgPdX3e4NWBg==", - "dev": true - }, - "walker": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz", - "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==", - "dev": true, - "requires": { - "makeerror": "1.0.12" - } - }, - "which": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", - "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", - "dev": true, - "requires": { - "isexe": "^2.0.0" - } - }, - "which-boxed-primitive": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", - "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", - "dev": true, - "requires": { - "is-bigint": "^1.0.1", - "is-boolean-object": "^1.1.0", - "is-number-object": "^1.0.4", - "is-string": "^1.0.5", - "is-symbol": "^1.0.3" - } - }, - "word-wrap": { - "version": "1.2.3", - "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", - "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==", - "dev": true - }, - "wrap-ansi": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz", - "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==", - "dev": true, - "requires": { - "ansi-styles": "^4.0.0", - "string-width": "^4.1.0", - "strip-ansi": "^6.0.0" - } - }, - "wrappy": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", - "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", - "dev": true - }, - "write-file-atomic": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-4.0.2.tgz", - "integrity": "sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==", - "dev": true, - "requires": { - "imurmurhash": "^0.1.4", - "signal-exit": "^3.0.7" - } - }, - "xtend": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", - "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==" - }, - "y18n": { - "version": "5.0.8", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", - "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", - "dev": true - }, - "yallist": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", - "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", - "dev": true - }, - "yaml": { - "version": "1.10.2", - "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz", - "integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==", - "dev": true - }, - "yargs": { - "version": "17.6.2", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.6.2.tgz", - "integrity": "sha512-1/9UrdHjDZc0eOU0HxOHoS78C69UD3JRMvzlJ7S79S2nTaWRA/whGCTV8o9e/N/1Va9YIV7Q4sOxD8VV4pCWOw==", - "dev": true, - "requires": { - "cliui": "^8.0.1", - "escalade": "^3.1.1", - "get-caller-file": "^2.0.5", - "require-directory": "^2.1.1", - "string-width": "^4.2.3", - "y18n": "^5.0.5", - "yargs-parser": "^21.1.1" - } - }, - "yargs-parser": { - "version": "21.1.1", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", - "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", - "dev": true - }, - "yocto-queue": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", - "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", - "dev": true - } } } diff --git a/samples/typescript/apiHelper.ts b/samples/typescript/apiHelper.ts index e52b037..cccdba9 100644 --- a/samples/typescript/apiHelper.ts +++ b/samples/typescript/apiHelper.ts @@ -11,7 +11,7 @@ open('API-helper example', Protocol.KittyHawk) }); async function doStuff(apiHelper: ApiHelper) { - const { systemEvents, simulationVariables } = apiHelper; + const { systemEvents, simulationVariables, facilities } = apiHelper; /** Subscribe to a system event */ systemEvents.addEventListener('Pause', data => { @@ -80,4 +80,20 @@ async function doStuff(apiHelper: ApiHelper) { }, err => console.log(err) ); + + /** + * The property names and corresponding data types are defined here: + * https://docs.flightsimulator.com/html/Programming_Tools/SimConnect/API_Reference/Facilities/SimConnect_AddToFacilityDefinition.htm + */ + const airportInfo = await facilities.getAirport('ENKJ', { + ICAO: SimConnectDataType.STRING8, + NAME: SimConnectDataType.STRING32, + RUNWAY: { + // TODO: fix return type. This should be a list in the returned type definition + PRIMARY_NUMBER: SimConnectDataType.INT32, + HEADING: SimConnectDataType.FLOAT32, + LENGTH: SimConnectDataType.FLOAT32, + }, + }); + console.log('Got airport', airportInfo); } diff --git a/src/ApiHelper/FacilitiesHelper.ts b/src/ApiHelper/FacilitiesHelper.ts index fe471dd..1b25c1d 100644 --- a/src/ApiHelper/FacilitiesHelper.ts +++ b/src/ApiHelper/FacilitiesHelper.ts @@ -3,7 +3,10 @@ import { SimConnectConnection } from '../SimConnectConnection'; import { SimConnectDataType } from '../enums/SimConnectDataType'; import { JavascriptDataType, readSimConnectValue } from './utils'; import { FacilityDataType } from '../enums/FacilityDataType'; -import { RecvFacilityData } from '../recv'; +import { RawBuffer } from '../RawBuffer'; +import { IcaoType } from '../dto'; +import { SimConnectError } from './SimulationVariablesHelper'; +import { SimConnectException } from '../enums/SimConnectException'; export class FacilitiesHelper extends BaseHelper { private _nextFacilityDefinition: number; @@ -16,18 +19,134 @@ export class FacilitiesHelper extends BaseHelper { this._nextRequestId = 0; } - async get(icao: string, facilityDefinition: T) { - return new Promise>(resolve => { + /** + * @param icao + * @param facilityDefinition + */ + public async getAirport(icao: string, facilityDefinition: T) { + return this._requestFacilityByEntryPoint('AIRPORT', icao, facilityDefinition); + } + + /** + * @param icao + * @param facilityDefinition + * @param options + */ + public async getWaypoint( + icao: string, + facilityDefinition: T, + options?: { region?: string; type?: IcaoType } + ) { + return this._requestFacilityByEntryPoint( + 'WAYPOINT', + icao, + facilityDefinition, + options?.region, + options?.type + ); + } + + /** + * + * @param icao + * @param facilityDefinition + * @param options + */ + public async getNDB( + icao: string, + facilityDefinition: T, + options?: { region?: string; type?: IcaoType } + ) { + return this._requestFacilityByEntryPoint( + 'NDB', + icao, + facilityDefinition, + options?.region, + options?.type + ); + } + + /** + * + * @param icao + * @param facilityDefinition + * @param options + */ + public async getVOR( + icao: string, + facilityDefinition: T, + options?: { region?: string; type?: IcaoType } + ) { + return this._requestFacilityByEntryPoint( + 'VOR', + icao, + facilityDefinition, + options?.region, + options?.type + ); + } + + private _requestFacilityByEntryPoint( + entryPoint: 'AIRPORT' | 'WAYPOINT' | 'NDB' | 'VOR', + icao: string, + facilityDefinition: T, + region?: string, + type?: IcaoType + ) { + return new Promise>((resolve, reject) => { const defineId = this._nextFacilityDefinition++; const requestId = this._nextRequestId++; - this._registerObject(defineId, facilityDefinition); - - this._handle.requestFacilityData(defineId, requestId, icao); + this._registerFacilityDefinitionRecursively( + defineId, + { + [entryPoint]: facilityDefinition, + }, + err => { + reject(err); + } + ); + const sendId = this._handle.requestFacilityData( + defineId, + requestId, + icao, + region, + type + ); + this._checkForException(sendId, ex => + reject( + new Error( + `${ + SimConnectException[ex] + }: Facility data request for '${icao}' (${entryPoint}) failed. ${ + explainRequestFacilityDataError(ex) || '' + }` + ) + ) + ); let output = {} as FacilityOutput; this._handle.on('facilityData', recvFacilityData => { - output = { ...output, ...readObject(facilityDefinition, recvFacilityData, output) }; + if (recvFacilityData.userRequestId === requestId) { + const propName = FacilityDataType[recvFacilityData.type]; + + if (propName === entryPoint) { + const airportData = readObject(facilityDefinition, recvFacilityData.data); + output = { ...output, ...airportData }; + } else { + const object = readObject( + // @ts-ignore + facilityDefinition[propName], + recvFacilityData.data + ); + output = { + ...output, + [propName]: + // @ts-ignore + propName in output ? [...output[propName], object] : [object], + }; + } + } }); this._handle.on('facilityDataEnd', recvFacilityDataEnd => { @@ -38,17 +157,48 @@ export class FacilitiesHelper extends BaseHelper { }); } - private _registerObject(defineId: number, definition: FacilityDefinition) { + private _registerFacilityDefinitionRecursively( + defineId: number, + definition: { [key: string]: FacilityRequest } | FacilityRequest, + exceptionHandler: (err: SimConnectError) => void, + objectName?: string + ) { const names = Object.keys(definition); - names.forEach((name, index) => { - const value = definition[name]; - if (typeof value === 'object') { - this._handle.addToFacilityDefinition(defineId, `OPEN ${name}`); - this._registerObject(defineId, value); - } else if (index === names.length - 1) { - this._handle.addToFacilityDefinition(defineId, `CLOSE ${name}`); - } else { - this._handle.addToFacilityDefinition(defineId, name); + names.forEach((propName, index) => { + let hasFailed = false; + function handleException(ex: SimConnectException) { + const explanation = explainAddToFacilityDefinitionError(ex); + hasFailed = true; + exceptionHandler({ + message: `${ + SimConnectException[ex] + }: Failed to add field name '${propName}' to the facility definition. ${ + explanation || '' + }`, + exception: ex, + }); + } + + const value = definition[propName]; + if (typeof value === 'object' && !hasFailed) { + const sendId = this._handle.addToFacilityDefinition(defineId, `OPEN ${propName}`); + this._checkForException(sendId, handleException); + this._registerFacilityDefinitionRecursively( + defineId, + value, + exceptionHandler, + propName + ); + } else if (!hasFailed) { + const sendId = this._handle.addToFacilityDefinition(defineId, propName); + this._checkForException(sendId, handleException); + } + if (index === names.length - 1 && objectName && !hasFailed) { + const sendId = this._handle.addToFacilityDefinition( + defineId, + `CLOSE ${objectName}` + ); + this._checkForException(sendId, handleException); } }); } @@ -57,44 +207,51 @@ export class FacilitiesHelper extends BaseHelper { /** * Reads the facility data recursively based on the user defined structure */ -function readObject( +function readObject( facilityDefinition: T, - recvData: RecvFacilityData, - accumulated: FacilityOutput + rawBuffer: RawBuffer ): FacilityOutput { - const output = accumulated; - + let output = {}; Object.keys(facilityDefinition).forEach((propName: keyof T) => { - const valueToRead: SimConnectDataType | FacilityDefinition = facilityDefinition[propName]; - if (typeof valueToRead === 'object') { - /** - * The data type we received should match one of the propnames of facilityDefinition (AIRPORT, RUNWAY, FREQUENCY, etc). - * Does the current propname match? - */ - if (propName === FacilityDataType[recvData.type]) { - // We will be reading a facility data type - output[propName] = readObject( - valueToRead, - recvData, - output - ) as FacilityOutput[typeof propName]; - } - // Nope, check next propName - } else { - // The current prop is a value - output[propName] = readSimConnectValue( - recvData.data, - valueToRead - ) as FacilityOutput[typeof propName]; + const valueType = facilityDefinition[propName]; + if (typeof valueType !== 'object') { + output = { + ...output, + [propName]: readSimConnectValue(rawBuffer, valueType), + }; } }); - return output; + return output as FacilityOutput; } -type FacilityOutput = { - [K in keyof T]: T[K] extends SimConnectDataType ? JavascriptDataType[T[K]] : FacilityOutput; +type FacilityOutput = { + [EntryPoint in keyof Def]: { + [Child in keyof Def[EntryPoint]]: Def[EntryPoint][Child] extends SimConnectDataType + ? JavascriptDataType[Def[EntryPoint][Child]] + : Def[EntryPoint][Child][]; + }; }; -type FacilityDefinition = { - [dataName: string]: SimConnectDataType | FacilityDefinition; +type FacilityRequest = { + [propName: string]: SimConnectDataType | { [propName: string]: SimConnectDataType }; }; + +// https://docs.flightsimulator.com/html/Programming_Tools/SimConnect/API_Reference/Facilities/SimConnect_RequestFacilityData.htm +function explainRequestFacilityDataError(ex: SimConnectException): string | undefined { + switch (ex) { + case SimConnectException.ERROR: + return 'Invalid ICAO and/or region parameter.'; + default: + return undefined; + } +} + +// https://docs.flightsimulator.com/html/Programming_Tools/SimConnect/API_Reference/Facilities/SimConnect_AddToFacilityDefinition.htm +function explainAddToFacilityDefinitionError(ex: SimConnectException) { + switch (ex) { + case SimConnectException.DATA_ERROR: + return 'This field name is not supported by this facility type.'; + default: + return undefined; + } +} diff --git a/src/SimConnectConnection.ts b/src/SimConnectConnection.ts index 08c2208..2c7f7d7 100644 --- a/src/SimConnectConnection.ts +++ b/src/SimConnectConnection.ts @@ -1413,7 +1413,6 @@ class SimConnectConnection extends EventEmitter { * @returns sendId of packet (can be used to identify packet when exception event occurs) */ addToFacilityDefinition(dataDefinitionId: DataDefinitionId, fieldName: string): number { - console.log(fieldName); if (this._ourProtocol < Protocol.KittyHawk) throw Error(SimConnectError.BadVersion); return this._buildAndSend( From 03a2764061cac991b6cef7eb1b318f026e2cdfe4 Mon Sep 17 00:00:00 2001 From: Even Rognlien Date: Sun, 4 Feb 2024 12:51:43 +0100 Subject: [PATCH 07/12] Upgrade typescript and prettier --- package-lock.json | 1810 ++++++++++++++++++++++++++++----------------- package.json | 24 +- 2 files changed, 1123 insertions(+), 711 deletions(-) diff --git a/package-lock.json b/package-lock.json index 3dc8c29..187ee45 100644 --- a/package-lock.json +++ b/package-lock.json @@ -20,24 +20,33 @@ "@types/debug": "^4.1.7", "@types/ini": "^1.3.30", "@types/jest": "^29.2.4", - "@typescript-eslint/eslint-plugin": "^5.26.0", - "@typescript-eslint/parser": "^5.26.0", - "eslint": "^8.16.0", + "@typescript-eslint/eslint-plugin": "^6.20.0", + "@typescript-eslint/parser": "^6.20.0", + "eslint": "^8.56.0", "eslint-config-airbnb-base": "^15.0.0", - "eslint-config-airbnb-typescript": "^17.0.0", - "eslint-config-prettier": "^8.5.0", - "eslint-plugin-import": "^2.26.0", - "eslint-plugin-prettier": "^4.0.0", - "eslint-plugin-simple-import-sort": "^7.0.0", + "eslint-config-airbnb-typescript": "^17.1.0", + "eslint-config-prettier": "^9.1.0", + "eslint-plugin-import": "^2.29.1", + "eslint-plugin-prettier": "^5.1.3", + "eslint-plugin-simple-import-sort": "^10.0.0", "eslint-plugin-tsdoc": "^0.2.17", "husky": "^8.0.1", "jest": "^29.3.1", "lint-staged": "^12.4.2", - "prettier": "^2.6.2", - "pretty-quick": "^3.1.0", + "prettier": "^3.2.5", + "pretty-quick": "^4.0.0", "ts-jest": "^29.0.3", - "typedoc": "^0.25.4", - "typescript": "^4.9.4" + "typedoc": "^0.25.7", + "typescript": "^5.3.3" + } + }, + "node_modules/@aashutoshrathi/word-wrap": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@aashutoshrathi/word-wrap/-/word-wrap-1.2.6.tgz", + "integrity": "sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==", + "dev": true, + "engines": { + "node": ">=0.10.0" } }, "node_modules/@ampproject/remapping": { @@ -624,16 +633,40 @@ "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", "dev": true }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", + "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==", + "dev": true, + "dependencies": { + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.10.0", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.10.0.tgz", + "integrity": "sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==", + "dev": true, + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, "node_modules/@eslint/eslintrc": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-1.3.0.tgz", - "integrity": "sha512-UWW0TMTmk2d7hLcWD1/e2g5HDM/HQ3csaLSqXCfqwh4uNDuNqlaKWXmEsL4Cs41Z0KnILNvwbHAah3C2yt06kw==", + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", + "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==", "dev": true, "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", - "espree": "^9.3.2", - "globals": "^13.15.0", + "espree": "^9.6.0", + "globals": "^13.19.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.0", @@ -642,6 +675,9 @@ }, "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" } }, "node_modules/@eslint/eslintrc/node_modules/argparse": { @@ -651,9 +687,9 @@ "dev": true }, "node_modules/@eslint/eslintrc/node_modules/globals": { - "version": "13.15.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.15.0.tgz", - "integrity": "sha512-bpzcOlgDhMG070Av0Vy5Owklpv1I6+j96GhUI7Rh7IzDCKLzboflLrrfqMu8NquDbiR4EOQk7XzJwqVJxicxog==", + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", "dev": true, "dependencies": { "type-fest": "^0.20.2" @@ -677,36 +713,46 @@ "js-yaml": "bin/js-yaml.js" } }, - "node_modules/@eslint/eslintrc/node_modules/type-fest": { - "version": "0.20.2", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", - "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "node_modules/@eslint/js": { + "version": "8.56.0", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.56.0.tgz", + "integrity": "sha512-gMsVel9D7f2HLkBma9VbtzZRehRogVRfbr++f06nL2vnCGCNlzOD+/MUov/F4p8myyAHspEhVobgjpX64q5m6A==", "dev": true, "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" } }, "node_modules/@humanwhocodes/config-array": { - "version": "0.9.5", - "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.9.5.tgz", - "integrity": "sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==", + "version": "0.11.14", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.14.tgz", + "integrity": "sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==", "dev": true, "dependencies": { - "@humanwhocodes/object-schema": "^1.2.1", - "debug": "^4.1.1", - "minimatch": "^3.0.4" + "@humanwhocodes/object-schema": "^2.0.2", + "debug": "^4.3.1", + "minimatch": "^3.0.5" }, "engines": { "node": ">=10.10.0" } }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, "node_modules/@humanwhocodes/object-schema": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", - "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.2.tgz", + "integrity": "sha512-6EwiSjwWYP7pTckG6I5eyFANjPhmPjUX9JRLUSfNPC7FX7zK9gyZAfUEaECL6ALTpGX5AjnBq3C9XmVWPitNpw==", "dev": true }, "node_modules/@istanbuljs/load-nyc-config": { @@ -1121,6 +1167,18 @@ "node": ">= 8" } }, + "node_modules/@pkgr/core": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.1.1.tgz", + "integrity": "sha512-cq8o4cWH0ibXh9VGi5P20Tu9XF/0fFXl9EUinr9QfTM7a7p0oTA4iJRCQWppXR1Pg8dSM0UCItCkPwsk9qWWYA==", + "dev": true, + "engines": { + "node": "^12.20.0 || ^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/unts" + } + }, "node_modules/@sinclair/typebox": { "version": "0.24.51", "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.24.51.tgz", @@ -1255,9 +1313,9 @@ } }, "node_modules/@types/json-schema": { - "version": "7.0.11", - "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz", - "integrity": "sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==", + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", "dev": true }, "node_modules/@types/json5": { @@ -1272,12 +1330,6 @@ "integrity": "sha512-ZXyOOm83p7X8p3s0IYM3VeueNmHpkk/yMlP8CLeOnEcu6hIwPH7YjZBvhQkR0ZFS2DqZAxKtJ/M5fcuv3OU5BA==", "dev": true }, - "node_modules/@types/minimatch": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.3.tgz", - "integrity": "sha512-tHq6qdbT9U1IRSGf14CL0pUlULksvY9OZ+5eEgl1N7t+OA3tGvNpxJCzuKQlsNgCVwbAs670L1vcVQi8j9HjnA==", - "dev": true - }, "node_modules/@types/ms": { "version": "0.7.31", "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.31.tgz", @@ -1295,6 +1347,12 @@ "integrity": "sha512-ri0UmynRRvZiiUJdiz38MmIblKK+oH30MztdBVR95dv/Ubw6neWSb8u1XpRb72L4qsZOhz+L+z9JD40SJmfWow==", "dev": true }, + "node_modules/@types/semver": { + "version": "7.5.6", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.6.tgz", + "integrity": "sha512-dn1l8LaMea/IjDoHNd9J52uBbInB796CDffS6VdIxvqYCPSG0V0DzHp76GpaWnlhg88uYyPbXCDIowa86ybd5A==", + "dev": true + }, "node_modules/@types/stack-utils": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.1.tgz", @@ -1317,31 +1375,33 @@ "dev": true }, "node_modules/@typescript-eslint/eslint-plugin": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.26.0.tgz", - "integrity": "sha512-oGCmo0PqnRZZndr+KwvvAUvD3kNE4AfyoGCwOZpoCncSh4MVD06JTE8XQa2u9u+NX5CsyZMBTEc2C72zx38eYA==", + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.20.0.tgz", + "integrity": "sha512-fTwGQUnjhoYHeSF6m5pWNkzmDDdsKELYrOBxhjMrofPqCkoC2k3B2wvGHFxa1CTIqkEn88nlW1HVMztjo2K8Hg==", "dev": true, "dependencies": { - "@typescript-eslint/scope-manager": "5.26.0", - "@typescript-eslint/type-utils": "5.26.0", - "@typescript-eslint/utils": "5.26.0", + "@eslint-community/regexpp": "^4.5.1", + "@typescript-eslint/scope-manager": "6.20.0", + "@typescript-eslint/type-utils": "6.20.0", + "@typescript-eslint/utils": "6.20.0", + "@typescript-eslint/visitor-keys": "6.20.0", "debug": "^4.3.4", - "functional-red-black-tree": "^1.0.1", - "ignore": "^5.2.0", - "regexpp": "^3.2.0", - "semver": "^7.3.7", - "tsutils": "^3.21.0" + "graphemer": "^1.4.0", + "ignore": "^5.2.4", + "natural-compare": "^1.4.0", + "semver": "^7.5.4", + "ts-api-utils": "^1.0.1" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": "^16.0.0 || >=18.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/typescript-eslint" }, "peerDependencies": { - "@typescript-eslint/parser": "^5.0.0", - "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + "@typescript-eslint/parser": "^6.0.0 || ^6.0.0-alpha", + "eslint": "^7.0.0 || ^8.0.0" }, "peerDependenciesMeta": { "typescript": { @@ -1350,9 +1410,9 @@ } }, "node_modules/@typescript-eslint/eslint-plugin/node_modules/semver": { - "version": "7.3.7", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz", - "integrity": "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==", + "version": "7.5.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz", + "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==", "dev": true, "dependencies": { "lru-cache": "^6.0.0" @@ -1365,25 +1425,26 @@ } }, "node_modules/@typescript-eslint/parser": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.26.0.tgz", - "integrity": "sha512-n/IzU87ttzIdnAH5vQ4BBDnLPly7rC5VnjN3m0xBG82HK6rhRxnCb3w/GyWbNDghPd+NktJqB/wl6+YkzZ5T5Q==", + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-6.20.0.tgz", + "integrity": "sha512-bYerPDF/H5v6V76MdMYhjwmwgMA+jlPVqjSDq2cRqMi8bP5sR3Z+RLOiOMad3nsnmDVmn2gAFCyNgh/dIrfP/w==", "dev": true, "dependencies": { - "@typescript-eslint/scope-manager": "5.26.0", - "@typescript-eslint/types": "5.26.0", - "@typescript-eslint/typescript-estree": "5.26.0", + "@typescript-eslint/scope-manager": "6.20.0", + "@typescript-eslint/types": "6.20.0", + "@typescript-eslint/typescript-estree": "6.20.0", + "@typescript-eslint/visitor-keys": "6.20.0", "debug": "^4.3.4" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": "^16.0.0 || >=18.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/typescript-eslint" }, "peerDependencies": { - "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + "eslint": "^7.0.0 || ^8.0.0" }, "peerDependenciesMeta": { "typescript": { @@ -1392,16 +1453,16 @@ } }, "node_modules/@typescript-eslint/scope-manager": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.26.0.tgz", - "integrity": "sha512-gVzTJUESuTwiju/7NiTb4c5oqod8xt5GhMbExKsCTp6adU3mya6AGJ4Pl9xC7x2DX9UYFsjImC0mA62BCY22Iw==", + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-6.20.0.tgz", + "integrity": "sha512-p4rvHQRDTI1tGGMDFQm+GtxP1ZHyAh64WANVoyEcNMpaTFn3ox/3CcgtIlELnRfKzSs/DwYlDccJEtr3O6qBvA==", "dev": true, "dependencies": { - "@typescript-eslint/types": "5.26.0", - "@typescript-eslint/visitor-keys": "5.26.0" + "@typescript-eslint/types": "6.20.0", + "@typescript-eslint/visitor-keys": "6.20.0" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": "^16.0.0 || >=18.0.0" }, "funding": { "type": "opencollective", @@ -1409,24 +1470,25 @@ } }, "node_modules/@typescript-eslint/type-utils": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.26.0.tgz", - "integrity": "sha512-7ccbUVWGLmcRDSA1+ADkDBl5fP87EJt0fnijsMFTVHXKGduYMgienC/i3QwoVhDADUAPoytgjbZbCOMj4TY55A==", + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-6.20.0.tgz", + "integrity": "sha512-qnSobiJQb1F5JjN0YDRPHruQTrX7ICsmltXhkV536mp4idGAYrIyr47zF/JmkJtEcAVnIz4gUYJ7gOZa6SmN4g==", "dev": true, "dependencies": { - "@typescript-eslint/utils": "5.26.0", + "@typescript-eslint/typescript-estree": "6.20.0", + "@typescript-eslint/utils": "6.20.0", "debug": "^4.3.4", - "tsutils": "^3.21.0" + "ts-api-utils": "^1.0.1" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": "^16.0.0 || >=18.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/typescript-eslint" }, "peerDependencies": { - "eslint": "*" + "eslint": "^7.0.0 || ^8.0.0" }, "peerDependenciesMeta": { "typescript": { @@ -1435,12 +1497,12 @@ } }, "node_modules/@typescript-eslint/types": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.26.0.tgz", - "integrity": "sha512-8794JZFE1RN4XaExLWLI2oSXsVImNkl79PzTOOWt9h0UHROwJedNOD2IJyfL0NbddFllcktGIO2aOu10avQQyA==", + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-6.20.0.tgz", + "integrity": "sha512-MM9mfZMAhiN4cOEcUOEx+0HmuaW3WBfukBZPCfwSqFnQy0grXYtngKCqpQN339X3RrwtzspWJrpbrupKYUSBXQ==", "dev": true, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": "^16.0.0 || >=18.0.0" }, "funding": { "type": "opencollective", @@ -1448,21 +1510,22 @@ } }, "node_modules/@typescript-eslint/typescript-estree": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.26.0.tgz", - "integrity": "sha512-EyGpw6eQDsfD6jIqmXP3rU5oHScZ51tL/cZgFbFBvWuCwrIptl+oueUZzSmLtxFuSOQ9vDcJIs+279gnJkfd1w==", + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-6.20.0.tgz", + "integrity": "sha512-RnRya9q5m6YYSpBN7IzKu9FmLcYtErkDkc8/dKv81I9QiLLtVBHrjz+Ev/crAqgMNW2FCsoZF4g2QUylMnJz+g==", "dev": true, "dependencies": { - "@typescript-eslint/types": "5.26.0", - "@typescript-eslint/visitor-keys": "5.26.0", + "@typescript-eslint/types": "6.20.0", + "@typescript-eslint/visitor-keys": "6.20.0", "debug": "^4.3.4", "globby": "^11.1.0", "is-glob": "^4.0.3", - "semver": "^7.3.7", - "tsutils": "^3.21.0" + "minimatch": "9.0.3", + "semver": "^7.5.4", + "ts-api-utils": "^1.0.1" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": "^16.0.0 || >=18.0.0" }, "funding": { "type": "opencollective", @@ -1474,10 +1537,34 @@ } } }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dev": true, + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "dev": true, + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": { - "version": "7.3.7", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz", - "integrity": "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==", + "version": "7.5.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz", + "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==", "dev": true, "dependencies": { "lru-cache": "^6.0.0" @@ -1490,65 +1577,73 @@ } }, "node_modules/@typescript-eslint/utils": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.26.0.tgz", - "integrity": "sha512-PJFwcTq2Pt4AMOKfe3zQOdez6InIDOjUJJD3v3LyEtxHGVVRK3Vo7Dd923t/4M9hSH2q2CLvcTdxlLPjcIk3eg==", + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-6.20.0.tgz", + "integrity": "sha512-/EKuw+kRu2vAqCoDwDCBtDRU6CTKbUmwwI7SH7AashZ+W+7o8eiyy6V2cdOqN49KsTcASWsC5QeghYuRDTyOOg==", "dev": true, "dependencies": { - "@types/json-schema": "^7.0.9", - "@typescript-eslint/scope-manager": "5.26.0", - "@typescript-eslint/types": "5.26.0", - "@typescript-eslint/typescript-estree": "5.26.0", - "eslint-scope": "^5.1.1", - "eslint-utils": "^3.0.0" + "@eslint-community/eslint-utils": "^4.4.0", + "@types/json-schema": "^7.0.12", + "@types/semver": "^7.5.0", + "@typescript-eslint/scope-manager": "6.20.0", + "@typescript-eslint/types": "6.20.0", + "@typescript-eslint/typescript-estree": "6.20.0", + "semver": "^7.5.4" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": "^16.0.0 || >=18.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/typescript-eslint" }, "peerDependencies": { - "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + "eslint": "^7.0.0 || ^8.0.0" } }, - "node_modules/@typescript-eslint/utils/node_modules/eslint-scope": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", - "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "node_modules/@typescript-eslint/utils/node_modules/semver": { + "version": "7.5.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz", + "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==", "dev": true, "dependencies": { - "esrecurse": "^4.3.0", - "estraverse": "^4.1.1" + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" }, "engines": { - "node": ">=8.0.0" + "node": ">=10" } }, "node_modules/@typescript-eslint/visitor-keys": { - "version": "5.26.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.26.0.tgz", - "integrity": "sha512-wei+ffqHanYDOQgg/fS6Hcar6wAWv0CUPQ3TZzOWd2BLfgP539rb49bwua8WRAs7R6kOSLn82rfEu2ro6Llt8Q==", + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-6.20.0.tgz", + "integrity": "sha512-E8Cp98kRe4gKHjJD4NExXKz/zOJ1A2hhZc+IMVD6i7w4yjIvh6VyuRI0gRtxAsXtoC35uGMaQ9rjI2zJaXDEAw==", "dev": true, "dependencies": { - "@typescript-eslint/types": "5.26.0", - "eslint-visitor-keys": "^3.3.0" + "@typescript-eslint/types": "6.20.0", + "eslint-visitor-keys": "^3.4.1" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": "^16.0.0 || >=18.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/typescript-eslint" } }, + "node_modules/@ungap/structured-clone": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz", + "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==", + "dev": true + }, "node_modules/acorn": { - "version": "7.4.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz", - "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==", + "version": "8.11.3", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.3.tgz", + "integrity": "sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==", "dev": true, - "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -1673,25 +1768,32 @@ "sprintf-js": "~1.0.2" } }, - "node_modules/array-differ": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/array-differ/-/array-differ-3.0.0.tgz", - "integrity": "sha512-THtfYS6KtME/yIAhKjZ2ul7XI96lQGHRputJQHO80LAWQnuGP4iCIN8vdMRboGbIEYBwU33q8Tch1os2+X0kMg==", + "node_modules/array-buffer-byte-length": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.1.tgz", + "integrity": "sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==", "dev": true, + "dependencies": { + "call-bind": "^1.0.5", + "is-array-buffer": "^3.0.4" + }, "engines": { - "node": ">=8" + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" } }, "node_modules/array-includes": { - "version": "3.1.5", - "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.5.tgz", - "integrity": "sha512-iSDYZMMyTPkiFasVqfuAQnWAYcvO/SeBSCGKePoEthjp4LEMTe4uLc7b025o4jAZpHhihh8xPo99TNWUWWkGDQ==", + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.7.tgz", + "integrity": "sha512-dlcsNBIiWhPkHdOEEKnehA+RNUWDc4UqFtnIXU4uuYDPtA4LDkr7qip2p0VvFAEXNDr0yWZ9PJyIRiGjRLQzwQ==", "dev": true, "dependencies": { "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "es-abstract": "^1.19.5", - "get-intrinsic": "^1.1.1", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "get-intrinsic": "^1.2.1", "is-string": "^1.0.7" }, "engines": { @@ -1710,15 +1812,34 @@ "node": ">=8" } }, + "node_modules/array.prototype.findlastindex": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.3.tgz", + "integrity": "sha512-LzLoiOMAxvy+Gd3BAq3B7VeIgPdo+Q8hthvKtXybMvRV0jrXfJM/t8mw7nNlpEcVlVUnCnM2KSX4XU5HmpodOA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "es-shim-unscopables": "^1.0.0", + "get-intrinsic": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/array.prototype.flat": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.0.tgz", - "integrity": "sha512-12IUEkHsAhA4DY5s0FPgNXIdc8VRSqD9Zp78a5au9abH/SOBrsp082JOWFNTjkMozh8mqcdiKuaLGhPeYztxSw==", + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.2.tgz", + "integrity": "sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==", "dev": true, "dependencies": { "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "es-abstract": "^1.19.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", "es-shim-unscopables": "^1.0.0" }, "engines": { @@ -1728,13 +1849,43 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/arrify": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/arrify/-/arrify-2.0.1.tgz", - "integrity": "sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==", + "node_modules/array.prototype.flatmap": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.2.tgz", + "integrity": "sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==", "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "es-shim-unscopables": "^1.0.0" + }, "engines": { - "node": ">=8" + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/arraybuffer.prototype.slice": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.2.tgz", + "integrity": "sha512-yMBKppFur/fbHu9/6USUe03bZ4knMYiwFBcyiaXB8Go0qNehwX6inYPzK9U0NeQvGxKthcmHcaR8P5MStSRBAw==", + "dev": true, + "dependencies": { + "array-buffer-byte-length": "^1.0.0", + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "get-intrinsic": "^1.2.1", + "is-array-buffer": "^3.0.2", + "is-shared-array-buffer": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" } }, "node_modules/astral-regex": { @@ -1746,6 +1897,18 @@ "node": ">=8" } }, + "node_modules/available-typed-arrays": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.6.tgz", + "integrity": "sha512-j1QzY8iPNPG4o4xmO3ptzpRxTciqD3MgEHtifP/YnJpIo58Xu+ne4BejlbkuaLfXn/nz6HFiw29bLpj2PNMdGg==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/babel-jest": { "version": "29.3.1", "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-29.3.1.tgz", @@ -1932,13 +2095,14 @@ } }, "node_modules/call-bind": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", - "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.5.tgz", + "integrity": "sha512-C3nQxfFZxFRVoJoGKKI8y3MOEo129NQ+FgQ08iye+Mk4zNZZGdjfs06bVTr+DBSlA66Q2VEcMki/cUCP4SercQ==", "dev": true, "dependencies": { - "function-bind": "^1.1.1", - "get-intrinsic": "^1.0.2" + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.1", + "set-function-length": "^1.1.1" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -2245,9 +2409,9 @@ "dev": true }, "node_modules/deep-is": { - "version": "0.1.3", - "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", - "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", "dev": true }, "node_modules/deepmerge": { @@ -2259,12 +2423,27 @@ "node": ">=0.10.0" } }, + "node_modules/define-data-property": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.1.tgz", + "integrity": "sha512-E7uGkTzkk1d0ByLeSc6ZsFS79Axg+m1P/VsgYsxHgiuc3tFSj+MjMIwe90FC4lOAZzNBdY7kkO2P2wKdsQ1vgQ==", + "dev": true, + "dependencies": { + "get-intrinsic": "^1.2.1", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/define-properties": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.4.tgz", - "integrity": "sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", + "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", "dev": true, "dependencies": { + "define-data-property": "^1.0.1", "has-property-descriptors": "^1.0.0", "object-keys": "^1.1.1" }, @@ -2338,15 +2517,6 @@ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true }, - "node_modules/end-of-stream": { - "version": "1.4.4", - "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", - "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", - "dev": true, - "dependencies": { - "once": "^1.4.0" - } - }, "node_modules/error-ex": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", @@ -2357,34 +2527,50 @@ } }, "node_modules/es-abstract": { - "version": "1.20.1", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.20.1.tgz", - "integrity": "sha512-WEm2oBhfoI2sImeM4OF2zE2V3BYdSF+KnSi9Sidz51fQHd7+JuF8Xgcj9/0o+OWeIeIS/MiuNnlruQrJf16GQA==", + "version": "1.22.3", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.22.3.tgz", + "integrity": "sha512-eiiY8HQeYfYH2Con2berK+To6GrK2RxbPawDkGq4UiCQQfZHb6wX9qQqkbpPqaxQFcl8d9QzZqo0tGE0VcrdwA==", "dev": true, "dependencies": { - "call-bind": "^1.0.2", + "array-buffer-byte-length": "^1.0.0", + "arraybuffer.prototype.slice": "^1.0.2", + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.5", + "es-set-tostringtag": "^2.0.1", "es-to-primitive": "^1.2.1", - "function-bind": "^1.1.1", - "function.prototype.name": "^1.1.5", - "get-intrinsic": "^1.1.1", + "function.prototype.name": "^1.1.6", + "get-intrinsic": "^1.2.2", "get-symbol-description": "^1.0.0", - "has": "^1.0.3", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", "has-symbols": "^1.0.3", - "internal-slot": "^1.0.3", - "is-callable": "^1.2.4", + "hasown": "^2.0.0", + "internal-slot": "^1.0.5", + "is-array-buffer": "^3.0.2", + "is-callable": "^1.2.7", "is-negative-zero": "^2.0.2", "is-regex": "^1.1.4", "is-shared-array-buffer": "^1.0.2", "is-string": "^1.0.7", + "is-typed-array": "^1.1.12", "is-weakref": "^1.0.2", - "object-inspect": "^1.12.0", + "object-inspect": "^1.13.1", "object-keys": "^1.1.1", - "object.assign": "^4.1.2", - "regexp.prototype.flags": "^1.4.3", - "string.prototype.trimend": "^1.0.5", - "string.prototype.trimstart": "^1.0.5", - "unbox-primitive": "^1.0.2" + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.5.1", + "safe-array-concat": "^1.0.1", + "safe-regex-test": "^1.0.0", + "string.prototype.trim": "^1.2.8", + "string.prototype.trimend": "^1.0.7", + "string.prototype.trimstart": "^1.0.7", + "typed-array-buffer": "^1.0.0", + "typed-array-byte-length": "^1.0.0", + "typed-array-byte-offset": "^1.0.0", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.13" }, "engines": { "node": ">= 0.4" @@ -2393,13 +2579,36 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/es-shim-unscopables": { + "node_modules/es-errors": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz", - "integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.0.0.tgz", + "integrity": "sha512-yHV74THqMJUyFKkHyN7hyENcEZM3Dj2a2IrdClY+IT4BFQHkIVwlh8s6uZfjsFydMdNHv0F5mWgAA3ajFbsvVQ==", + "dev": true, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.2.tgz", + "integrity": "sha512-BuDyupZt65P9D2D2vA/zqcI3G5xRsklm5N3xCwuiy+/vKy8i0ifdsQP1sLgO4tZDSCaQUSnmC48khknGMV3D2Q==", + "dev": true, + "dependencies": { + "get-intrinsic": "^1.2.2", + "has-tostringtag": "^1.0.0", + "hasown": "^2.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-shim-unscopables": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.2.tgz", + "integrity": "sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==", "dev": true, "dependencies": { - "has": "^1.0.3" + "hasown": "^2.0.0" } }, "node_modules/es-to-primitive": { @@ -2438,46 +2647,49 @@ } }, "node_modules/eslint": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.16.0.tgz", - "integrity": "sha512-MBndsoXY/PeVTDJeWsYj7kLZ5hQpJOfMYLsF6LicLHQWbRDG19lK5jOix4DPl8yY4SUFcE3txy86OzFLWT+yoA==", - "dev": true, - "dependencies": { - "@eslint/eslintrc": "^1.3.0", - "@humanwhocodes/config-array": "^0.9.2", - "ajv": "^6.10.0", + "version": "8.56.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.56.0.tgz", + "integrity": "sha512-Go19xM6T9puCOWntie1/P997aXxFsOi37JIHRWI514Hc6ZnaHGKY9xFhrU65RT6CcBEzZoGG1e6Nq+DT04ZtZQ==", + "dev": true, + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.6.1", + "@eslint/eslintrc": "^2.1.4", + "@eslint/js": "8.56.0", + "@humanwhocodes/config-array": "^0.11.13", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "@ungap/structured-clone": "^1.2.0", + "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.2", "debug": "^4.3.2", "doctrine": "^3.0.0", "escape-string-regexp": "^4.0.0", - "eslint-scope": "^7.1.1", - "eslint-utils": "^3.0.0", - "eslint-visitor-keys": "^3.3.0", - "espree": "^9.3.2", - "esquery": "^1.4.0", + "eslint-scope": "^7.2.2", + "eslint-visitor-keys": "^3.4.3", + "espree": "^9.6.1", + "esquery": "^1.4.2", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^6.0.1", - "functional-red-black-tree": "^1.0.1", - "glob-parent": "^6.0.1", - "globals": "^13.15.0", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "graphemer": "^1.4.0", "ignore": "^5.2.0", - "import-fresh": "^3.0.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", "js-yaml": "^4.1.0", "json-stable-stringify-without-jsonify": "^1.0.1", "levn": "^0.4.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", - "optionator": "^0.9.1", - "regexpp": "^3.2.0", + "optionator": "^0.9.3", "strip-ansi": "^6.0.1", - "strip-json-comments": "^3.1.0", - "text-table": "^0.2.0", - "v8-compile-cache": "^2.0.3" + "text-table": "^0.2.0" }, "bin": { "eslint": "bin/eslint.js" @@ -2509,24 +2721,24 @@ } }, "node_modules/eslint-config-airbnb-typescript": { - "version": "17.0.0", - "resolved": "https://registry.npmjs.org/eslint-config-airbnb-typescript/-/eslint-config-airbnb-typescript-17.0.0.tgz", - "integrity": "sha512-elNiuzD0kPAPTXjFWg+lE24nMdHMtuxgYoD30OyMD6yrW1AhFZPAg27VX7d3tzOErw+dgJTNWfRSDqEcXb4V0g==", + "version": "17.1.0", + "resolved": "https://registry.npmjs.org/eslint-config-airbnb-typescript/-/eslint-config-airbnb-typescript-17.1.0.tgz", + "integrity": "sha512-GPxI5URre6dDpJ0CtcthSZVBAfI+Uw7un5OYNVxP2EYi3H81Jw701yFP7AU+/vCE7xBtFmjge7kfhhk4+RAiig==", "dev": true, "dependencies": { "eslint-config-airbnb-base": "^15.0.0" }, "peerDependencies": { - "@typescript-eslint/eslint-plugin": "^5.13.0", - "@typescript-eslint/parser": "^5.0.0", + "@typescript-eslint/eslint-plugin": "^5.13.0 || ^6.0.0", + "@typescript-eslint/parser": "^5.0.0 || ^6.0.0", "eslint": "^7.32.0 || ^8.2.0", "eslint-plugin-import": "^2.25.3" } }, "node_modules/eslint-config-prettier": { - "version": "8.5.0", - "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-8.5.0.tgz", - "integrity": "sha512-obmWKLUNCnhtQRKc+tmnYuQl0pFU1ibYJQ5BGhTVB08bHe9wC8qUeG7c08dj9XX+AuPj1YSGSQIHl1pnDHZR0Q==", + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-9.1.0.tgz", + "integrity": "sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==", "dev": true, "bin": { "eslint-config-prettier": "bin/cli.js" @@ -2536,13 +2748,14 @@ } }, "node_modules/eslint-import-resolver-node": { - "version": "0.3.6", - "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.6.tgz", - "integrity": "sha512-0En0w03NRVMn9Uiyn8YRPDKvWjxCWkslUEhGNTdGx15RvPJYQ+lbOlqrlNI2vEAs4pDYK4f/HN2TbDmk5TP0iw==", + "version": "0.3.9", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.9.tgz", + "integrity": "sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==", "dev": true, "dependencies": { "debug": "^3.2.7", - "resolve": "^1.20.0" + "is-core-module": "^2.13.0", + "resolve": "^1.22.4" } }, "node_modules/eslint-import-resolver-node/node_modules/debug": { @@ -2555,12 +2768,12 @@ } }, "node_modules/eslint-import-resolver-node/node_modules/resolve": { - "version": "1.22.0", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.0.tgz", - "integrity": "sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==", + "version": "1.22.8", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz", + "integrity": "sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==", "dev": true, "dependencies": { - "is-core-module": "^2.8.1", + "is-core-module": "^2.13.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, @@ -2572,16 +2785,20 @@ } }, "node_modules/eslint-module-utils": { - "version": "2.7.3", - "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.7.3.tgz", - "integrity": "sha512-088JEC7O3lDZM9xGe0RerkOMd0EjFl+Yvd1jPWIkMT5u3H9+HC34mWWPnqPrN13gieT9pBOO+Qt07Nb/6TresQ==", + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.8.0.tgz", + "integrity": "sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==", "dev": true, "dependencies": { - "debug": "^3.2.7", - "find-up": "^2.1.0" + "debug": "^3.2.7" }, "engines": { "node": ">=4" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + } } }, "node_modules/eslint-module-utils/node_modules/debug": { @@ -2593,92 +2810,29 @@ "ms": "^2.1.1" } }, - "node_modules/eslint-module-utils/node_modules/find-up": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", - "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", - "dev": true, - "dependencies": { - "locate-path": "^2.0.0" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/eslint-module-utils/node_modules/locate-path": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", - "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", - "dev": true, - "dependencies": { - "p-locate": "^2.0.0", - "path-exists": "^3.0.0" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/eslint-module-utils/node_modules/p-limit": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz", - "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==", - "dev": true, - "dependencies": { - "p-try": "^1.0.0" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/eslint-module-utils/node_modules/p-locate": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", - "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", - "dev": true, - "dependencies": { - "p-limit": "^1.1.0" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/eslint-module-utils/node_modules/p-try": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", - "integrity": "sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=", - "dev": true, - "engines": { - "node": ">=4" - } - }, - "node_modules/eslint-module-utils/node_modules/path-exists": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", - "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", - "dev": true, - "engines": { - "node": ">=4" - } - }, "node_modules/eslint-plugin-import": { - "version": "2.26.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.26.0.tgz", - "integrity": "sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA==", + "version": "2.29.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.29.1.tgz", + "integrity": "sha512-BbPC0cuExzhiMo4Ff1BTVwHpjjv28C5R+btTOGaCRC7UEz801up0JadwkeSk5Ued6TG34uaczuVuH6qyy5YUxw==", "dev": true, "dependencies": { - "array-includes": "^3.1.4", - "array.prototype.flat": "^1.2.5", - "debug": "^2.6.9", + "array-includes": "^3.1.7", + "array.prototype.findlastindex": "^1.2.3", + "array.prototype.flat": "^1.3.2", + "array.prototype.flatmap": "^1.3.2", + "debug": "^3.2.7", "doctrine": "^2.1.0", - "eslint-import-resolver-node": "^0.3.6", - "eslint-module-utils": "^2.7.3", - "has": "^1.0.3", - "is-core-module": "^2.8.1", + "eslint-import-resolver-node": "^0.3.9", + "eslint-module-utils": "^2.8.0", + "hasown": "^2.0.0", + "is-core-module": "^2.13.1", "is-glob": "^4.0.3", "minimatch": "^3.1.2", - "object.values": "^1.1.5", - "resolve": "^1.22.0", - "tsconfig-paths": "^3.14.1" + "object.fromentries": "^2.0.7", + "object.groupby": "^1.0.1", + "object.values": "^1.1.7", + "semver": "^6.3.1", + "tsconfig-paths": "^3.15.0" }, "engines": { "node": ">=4" @@ -2688,12 +2842,12 @@ } }, "node_modules/eslint-plugin-import/node_modules/debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", "dev": true, "dependencies": { - "ms": "2.0.0" + "ms": "^2.1.1" } }, "node_modules/eslint-plugin-import/node_modules/doctrine": { @@ -2708,54 +2862,40 @@ "node": ">=0.10.0" } }, - "node_modules/eslint-plugin-import/node_modules/ms": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", - "dev": true - }, - "node_modules/eslint-plugin-import/node_modules/resolve": { - "version": "1.22.0", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.0.tgz", - "integrity": "sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==", - "dev": true, - "dependencies": { - "is-core-module": "^2.8.1", - "path-parse": "^1.0.7", - "supports-preserve-symlinks-flag": "^1.0.0" - }, - "bin": { - "resolve": "bin/resolve" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, "node_modules/eslint-plugin-prettier": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-4.0.0.tgz", - "integrity": "sha512-98MqmCJ7vJodoQK359bqQWaxOE0CS8paAz/GgjaZLyex4TTk3g9HugoO89EqWCrFiOqn9EVvcoo7gZzONCWVwQ==", + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.1.3.tgz", + "integrity": "sha512-C9GCVAs4Eq7ZC/XFQHITLiHJxQngdtraXaM+LoUFoFp/lHNl2Zn8f3WQbe9HvTBBQ9YnKFB0/2Ajdqwo5D1EAw==", "dev": true, "dependencies": { - "prettier-linter-helpers": "^1.0.0" + "prettier-linter-helpers": "^1.0.0", + "synckit": "^0.8.6" }, "engines": { - "node": ">=6.0.0" + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint-plugin-prettier" }, "peerDependencies": { - "eslint": ">=7.28.0", - "prettier": ">=2.0.0" + "@types/eslint": ">=8.0.0", + "eslint": ">=8.0.0", + "eslint-config-prettier": "*", + "prettier": ">=3.0.0" }, "peerDependenciesMeta": { + "@types/eslint": { + "optional": true + }, "eslint-config-prettier": { "optional": true } } }, "node_modules/eslint-plugin-simple-import-sort": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-simple-import-sort/-/eslint-plugin-simple-import-sort-7.0.0.tgz", - "integrity": "sha512-U3vEDB5zhYPNfxT5TYR7u01dboFZp+HNpnGhkDB2g/2E4wZ/g1Q9Ton8UwCLfRV9yAKyYqDh62oHOamvkFxsvw==", + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-simple-import-sort/-/eslint-plugin-simple-import-sort-10.0.0.tgz", + "integrity": "sha512-AeTvO9UCMSNzIHRkg8S6c3RPy5YEwKWSQPx3DYghLedo2ZQxowPFLGDN1AZ2evfg6r6mjBSZSLxLFsWSu3acsw==", "dev": true, "peerDependencies": { "eslint": ">=5.0.0" @@ -2778,9 +2918,9 @@ "dev": true }, "node_modules/eslint-scope": { - "version": "7.1.1", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz", - "integrity": "sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==", + "version": "7.2.2", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", + "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", "dev": true, "dependencies": { "esrecurse": "^4.3.0", @@ -2788,51 +2928,21 @@ }, "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" - } - }, - "node_modules/eslint-scope/node_modules/estraverse": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", - "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", - "dev": true, - "engines": { - "node": ">=4.0" - } - }, - "node_modules/eslint-utils": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-3.0.0.tgz", - "integrity": "sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==", - "dev": true, - "dependencies": { - "eslint-visitor-keys": "^2.0.0" - }, - "engines": { - "node": "^10.0.0 || ^12.0.0 || >= 14.0.0" }, "funding": { - "url": "https://github.com/sponsors/mysticatea" - }, - "peerDependencies": { - "eslint": ">=5" - } - }, - "node_modules/eslint-utils/node_modules/eslint-visitor-keys": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz", - "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==", - "dev": true, - "engines": { - "node": ">=10" + "url": "https://opencollective.com/eslint" } }, "node_modules/eslint-visitor-keys": { - "version": "3.3.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz", - "integrity": "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==", + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", "dev": true, "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" } }, "node_modules/eslint/node_modules/argparse": { @@ -2853,10 +2963,26 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/eslint/node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/eslint/node_modules/globals": { - "version": "13.15.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.15.0.tgz", - "integrity": "sha512-bpzcOlgDhMG070Av0Vy5Owklpv1I6+j96GhUI7Rh7IzDCKLzboflLrrfqMu8NquDbiR4EOQk7XzJwqVJxicxog==", + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", "dev": true, "dependencies": { "type-fest": "^0.20.2" @@ -2880,62 +3006,44 @@ "js-yaml": "bin/js-yaml.js" } }, - "node_modules/eslint/node_modules/levn": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", - "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "node_modules/eslint/node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", "dev": true, "dependencies": { - "prelude-ls": "^1.2.1", - "type-check": "~0.4.0" + "p-locate": "^5.0.0" }, "engines": { - "node": ">= 0.8.0" + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/eslint/node_modules/optionator": { - "version": "0.9.1", - "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz", - "integrity": "sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==", + "node_modules/eslint/node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", "dev": true, "dependencies": { - "deep-is": "^0.1.3", - "fast-levenshtein": "^2.0.6", - "levn": "^0.4.1", - "prelude-ls": "^1.2.1", - "type-check": "^0.4.0", - "word-wrap": "^1.2.3" + "yocto-queue": "^0.1.0" }, "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/eslint/node_modules/prelude-ls": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", - "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", - "dev": true, - "engines": { - "node": ">= 0.8.0" + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/eslint/node_modules/type-check": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", - "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "node_modules/eslint/node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", "dev": true, "dependencies": { - "prelude-ls": "^1.2.1" + "p-limit": "^3.0.2" }, - "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/eslint/node_modules/type-fest": { - "version": "0.20.2", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", - "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", - "dev": true, "engines": { "node": ">=10" }, @@ -2944,29 +3052,20 @@ } }, "node_modules/espree": { - "version": "9.3.2", - "resolved": "https://registry.npmjs.org/espree/-/espree-9.3.2.tgz", - "integrity": "sha512-D211tC7ZwouTIuY5x9XnS0E9sWNChB7IYKX/Xp5eQj3nFXhqmiUDB9q27y76oFl8jTg3pXcQx/bpxMfs3CIZbA==", + "version": "9.6.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", + "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", "dev": true, "dependencies": { - "acorn": "^8.7.1", + "acorn": "^8.9.0", "acorn-jsx": "^5.3.2", - "eslint-visitor-keys": "^3.3.0" + "eslint-visitor-keys": "^3.4.1" }, "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" - } - }, - "node_modules/espree/node_modules/acorn": { - "version": "8.7.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz", - "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==", - "dev": true, - "bin": { - "acorn": "bin/acorn" }, - "engines": { - "node": ">=0.4.0" + "funding": { + "url": "https://opencollective.com/eslint" } }, "node_modules/esprima": { @@ -2983,9 +3082,9 @@ } }, "node_modules/esquery": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.4.0.tgz", - "integrity": "sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==", + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz", + "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==", "dev": true, "dependencies": { "estraverse": "^5.1.0" @@ -2994,15 +3093,6 @@ "node": ">=0.10" } }, - "node_modules/esquery/node_modules/estraverse": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", - "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", - "dev": true, - "engines": { - "node": ">=4.0" - } - }, "node_modules/esrecurse": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", @@ -3015,7 +3105,7 @@ "node": ">=4.0" } }, - "node_modules/esrecurse/node_modules/estraverse": { + "node_modules/estraverse": { "version": "5.3.0", "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", @@ -3024,15 +3114,6 @@ "node": ">=4.0" } }, - "node_modules/estraverse": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", - "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", - "dev": true, - "engines": { - "node": ">=4.0" - } - }, "node_modules/esutils": { "version": "2.0.3", "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", @@ -3121,9 +3202,9 @@ "dev": true }, "node_modules/fast-glob": { - "version": "3.2.11", - "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.11.tgz", - "integrity": "sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew==", + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz", + "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==", "dev": true, "dependencies": { "@nodelib/fs.stat": "^2.0.2", @@ -3157,13 +3238,13 @@ "node_modules/fast-levenshtein": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", - "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", "dev": true }, "node_modules/fastq": { - "version": "1.13.0", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.13.0.tgz", - "integrity": "sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==", + "version": "1.17.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.0.tgz", + "integrity": "sha512-zGygtijUMT7jnk3h26kUms3BkSDp4IfIKjmnqI2tvx6nuBfiF1UqOxbnLfzdv+apBy+53oaImsKtMw/xYbW+1w==", "dev": true, "dependencies": { "reusify": "^1.0.4" @@ -3234,6 +3315,15 @@ "integrity": "sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==", "dev": true }, + "node_modules/for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dev": true, + "dependencies": { + "is-callable": "^1.1.3" + } + }, "node_modules/fs.realpath": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", @@ -3255,21 +3345,24 @@ } }, "node_modules/function-bind": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", - "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", - "dev": true + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } }, "node_modules/function.prototype.name": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", - "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.6.tgz", + "integrity": "sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==", "dev": true, "dependencies": { "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "es-abstract": "^1.19.0", - "functions-have-names": "^1.2.2" + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "functions-have-names": "^1.2.3" }, "engines": { "node": ">= 0.4" @@ -3278,12 +3371,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/functional-red-black-tree": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", - "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", - "dev": true - }, "node_modules/functions-have-names": { "version": "1.2.3", "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", @@ -3312,14 +3399,19 @@ } }, "node_modules/get-intrinsic": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz", - "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==", + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.3.tgz", + "integrity": "sha512-JIcZczvcMVE7AUOP+X72bh8HqHBRxFdz5PDHYtNG/lE3yk9b3KZBJlwFcTyPYjg3L4RLLmZJzvjxhaZVapxFrQ==", "dev": true, "dependencies": { - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-symbols": "^1.0.1" + "es-errors": "^1.0.0", + "function-bind": "^1.1.2", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "hasown": "^2.0.0" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -3403,6 +3495,21 @@ "node": ">=4" } }, + "node_modules/globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "dev": true, + "dependencies": { + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/globby": { "version": "11.1.0", "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", @@ -3423,23 +3530,29 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dev": true, + "dependencies": { + "get-intrinsic": "^1.1.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/graceful-fs": { "version": "4.2.10", "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", "dev": true }, - "node_modules/has": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", - "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", - "dev": true, - "dependencies": { - "function-bind": "^1.1.1" - }, - "engines": { - "node": ">= 0.4.0" - } + "node_modules/graphemer": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", + "dev": true }, "node_modules/has-bigints": { "version": "1.0.2", @@ -3460,12 +3573,24 @@ } }, "node_modules/has-property-descriptors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", - "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.1.tgz", + "integrity": "sha512-VsX8eaIewvas0xnvinAe9bw4WfIeODpGYikiWYLH+dma0Jw6KHYqWiWfhQlgOVK8D6PvjubK5Uc4P0iIhIcNVg==", "dev": true, "dependencies": { - "get-intrinsic": "^1.1.1" + "get-intrinsic": "^1.2.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "dev": true, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -3484,12 +3609,12 @@ } }, "node_modules/has-tostringtag": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", - "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", "dev": true, "dependencies": { - "has-symbols": "^1.0.2" + "has-symbols": "^1.0.3" }, "engines": { "node": ">= 0.4" @@ -3498,21 +3623,24 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/hasown": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.0.tgz", + "integrity": "sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==", + "dev": true, + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/html-escaper": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", "dev": true }, - "node_modules/human-signals": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-1.1.1.tgz", - "integrity": "sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==", - "dev": true, - "engines": { - "node": ">=8.12.0" - } - }, "node_modules/husky": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/husky/-/husky-8.0.1.tgz", @@ -3534,9 +3662,9 @@ "integrity": "sha1-VYaN6wCT08Z79xZudFNT+5vLIaI=" }, "node_modules/ignore": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.0.tgz", - "integrity": "sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==", + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.1.tgz", + "integrity": "sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==", "dev": true, "engines": { "node": ">= 4" @@ -3628,19 +3756,35 @@ } }, "node_modules/internal-slot": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.3.tgz", - "integrity": "sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA==", + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.6.tgz", + "integrity": "sha512-Xj6dv+PsbtwyPpEflsejS+oIZxmMlV44zAhG479uYu89MsjcYOhCFnNyKrkJrihbsiasQyY0afoCl/9BLR65bg==", "dev": true, "dependencies": { - "get-intrinsic": "^1.1.0", - "has": "^1.0.3", + "get-intrinsic": "^1.2.2", + "hasown": "^2.0.0", "side-channel": "^1.0.4" }, "engines": { "node": ">= 0.4" } }, + "node_modules/is-array-buffer": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.4.tgz", + "integrity": "sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-arrayish": { "version": "0.2.1", "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", @@ -3676,9 +3820,9 @@ } }, "node_modules/is-callable": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.4.tgz", - "integrity": "sha512-nsuwtxZfMX67Oryl9LCQ+upnC0Z0BgpwntpS89m1H/TLF0zNfzfLMV/9Wa/6MZsj0acpEjAO0KF1xT6ZdLl95w==", + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", "dev": true, "engines": { "node": ">= 0.4" @@ -3688,12 +3832,12 @@ } }, "node_modules/is-core-module": { - "version": "2.9.0", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz", - "integrity": "sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==", + "version": "2.13.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.13.1.tgz", + "integrity": "sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==", "dev": true, "dependencies": { - "has": "^1.0.3" + "hasown": "^2.0.0" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -3789,6 +3933,15 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, "node_modules/is-regex": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", @@ -3859,6 +4012,21 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/is-typed-array": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz", + "integrity": "sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==", + "dev": true, + "dependencies": { + "which-typed-array": "^1.1.14" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-weakref": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", @@ -4752,6 +4920,19 @@ "node": ">=6" } }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, "node_modules/lilconfig": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.0.4.tgz", @@ -5061,15 +5242,18 @@ } }, "node_modules/minimist": { - "version": "1.2.6", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz", - "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==", - "dev": true + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } }, "node_modules/mri": { - "version": "1.1.6", - "resolved": "https://registry.npmjs.org/mri/-/mri-1.1.6.tgz", - "integrity": "sha512-oi1b3MfbyGa7FJMP9GmLTttni5JoICpYBRlq+x5V16fZbLsnL9N3wFqqIm/nIG43FjUFkFh9Epzp/kzUGUnJxQ==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz", + "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==", "dev": true, "engines": { "node": ">=4" @@ -5080,22 +5264,6 @@ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" }, - "node_modules/multimatch": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/multimatch/-/multimatch-4.0.0.tgz", - "integrity": "sha512-lDmx79y1z6i7RNx0ZGCPq1bzJ6ZoDDKbvh7jxr9SJcWLkShMzXrHbYVpTdnhNM5MXpDUxCQ4DgqVttVXlBgiBQ==", - "dev": true, - "dependencies": { - "@types/minimatch": "^3.0.3", - "array-differ": "^3.0.0", - "array-union": "^2.1.0", - "arrify": "^2.0.1", - "minimatch": "^3.0.4" - }, - "engines": { - "node": ">=8" - } - }, "node_modules/natural-compare": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", @@ -5136,9 +5304,9 @@ } }, "node_modules/object-inspect": { - "version": "1.12.2", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.2.tgz", - "integrity": "sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ==", + "version": "1.13.1", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.1.tgz", + "integrity": "sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==", "dev": true, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -5154,14 +5322,14 @@ } }, "node_modules/object.assign": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz", - "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==", + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.5.tgz", + "integrity": "sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==", "dev": true, "dependencies": { - "call-bind": "^1.0.0", - "define-properties": "^1.1.3", - "has-symbols": "^1.0.1", + "call-bind": "^1.0.5", + "define-properties": "^1.2.1", + "has-symbols": "^1.0.3", "object-keys": "^1.1.1" }, "engines": { @@ -5185,15 +5353,44 @@ "node": ">= 0.4" } }, + "node_modules/object.fromentries": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.7.tgz", + "integrity": "sha512-UPbPHML6sL8PI/mOqPwsH4G6iyXcCGzLin8KvEPenOZN5lpCNBZZQ+V62vdjB1mQHrmqGQt5/OJzemUA+KJmEA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.groupby": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/object.groupby/-/object.groupby-1.0.1.tgz", + "integrity": "sha512-HqaQtqLnp/8Bn4GL16cj+CUYbnpe1bh0TtEaWvybszDG4tgxCJuRpV8VGuvNaI1fAnI4lUJzDG55MXcOH4JZcQ==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "get-intrinsic": "^1.2.1" + } + }, "node_modules/object.values": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.5.tgz", - "integrity": "sha512-QUZRW0ilQ3PnPpbNtgdNV1PDbEqLIiSFB3l+EnGtBQ/8SUTLj1PZwtQHABZtLgwpJZTSZhuGLOGk57Drx2IvYg==", + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.7.tgz", + "integrity": "sha512-aU6xnDFYT3x17e/f0IiiwlGPTy2jzMySGfUB4fq6z7CV8l85CWHDk5ErhyhpfDHhrOMwGFhSQkhMGHaIotA6Ng==", "dev": true, "dependencies": { "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "es-abstract": "^1.19.1" + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1" }, "engines": { "node": ">= 0.4" @@ -5226,6 +5423,23 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/optionator": { + "version": "0.9.3", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.3.tgz", + "integrity": "sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==", + "dev": true, + "dependencies": { + "@aashutoshrathi/word-wrap": "^1.2.3", + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, "node_modules/p-limit": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", @@ -5400,16 +5614,25 @@ "node": ">=8" } }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "engines": { + "node": ">= 0.8.0" + } + }, "node_modules/prettier": { - "version": "2.6.2", - "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.6.2.tgz", - "integrity": "sha512-PkUpF+qoXTqhOeWL9fu7As8LXsIUZ1WYaJiY/a7McAQzxjk82OF0tibkFXVCDImZtWxbvojFjerkiLb0/q8mew==", + "version": "3.2.5", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.2.5.tgz", + "integrity": "sha512-3/GWa9aOC0YeD7LUfvOG2NiDyhOWRvt1k+rcKhOuYnMY24iiCphgneUfJDyFXd6rZCAnuLBv6UeAULtrhT/F4A==", "dev": true, "bin": { - "prettier": "bin-prettier.js" + "prettier": "bin/prettier.cjs" }, "engines": { - "node": ">=10.13.0" + "node": ">=14" }, "funding": { "url": "https://github.com/prettier/prettier?sponsor=1" @@ -5454,79 +5677,102 @@ } }, "node_modules/pretty-quick": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/pretty-quick/-/pretty-quick-3.1.0.tgz", - "integrity": "sha512-DtxIxksaUWCgPFN7E1ZZk4+Aav3CCuRdhrDSFZENb404sYMtuo9Zka823F+Mgeyt8Zt3bUiCjFzzWYE9LYqkmQ==", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/pretty-quick/-/pretty-quick-4.0.0.tgz", + "integrity": "sha512-M+2MmeufXb/M7Xw3Afh1gxcYpj+sK0AxEfnfF958ktFeAyi5MsKY5brymVURQLgPLV1QaF5P4pb2oFJ54H3yzQ==", "dev": true, "dependencies": { - "chalk": "^3.0.0", - "execa": "^4.0.0", - "find-up": "^4.1.0", - "ignore": "^5.1.4", - "mri": "^1.1.5", - "multimatch": "^4.0.0" + "execa": "^5.1.1", + "find-up": "^5.0.0", + "ignore": "^5.3.0", + "mri": "^1.2.0", + "picocolors": "^1.0.0", + "picomatch": "^3.0.1", + "tslib": "^2.6.2" }, "bin": { - "pretty-quick": "bin/pretty-quick.js" + "pretty-quick": "lib/cli.mjs" }, "engines": { - "node": ">=10.13" + "node": ">=14" }, "peerDependencies": { - "prettier": ">=2.0.0" + "prettier": "^3.0.0" } }, - "node_modules/pretty-quick/node_modules/chalk": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz", - "integrity": "sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==", + "node_modules/pretty-quick/node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", "dev": true, "dependencies": { - "ansi-styles": "^4.1.0", - "supports-color": "^7.1.0" + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" }, "engines": { - "node": ">=8" + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/pretty-quick/node_modules/execa": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/execa/-/execa-4.1.0.tgz", - "integrity": "sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==", + "node_modules/pretty-quick/node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", "dev": true, "dependencies": { - "cross-spawn": "^7.0.0", - "get-stream": "^5.0.0", - "human-signals": "^1.1.1", - "is-stream": "^2.0.0", - "merge-stream": "^2.0.0", - "npm-run-path": "^4.0.0", - "onetime": "^5.1.0", - "signal-exit": "^3.0.2", - "strip-final-newline": "^2.0.0" + "p-locate": "^5.0.0" }, "engines": { "node": ">=10" }, "funding": { - "url": "https://github.com/sindresorhus/execa?sponsor=1" + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/pretty-quick/node_modules/get-stream": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", - "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "node_modules/pretty-quick/node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", "dev": true, "dependencies": { - "pump": "^3.0.0" + "yocto-queue": "^0.1.0" }, "engines": { - "node": ">=8" + "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/pretty-quick/node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pretty-quick/node_modules/picomatch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-3.0.1.tgz", + "integrity": "sha512-I3EurrIQMlRc9IaAZnqRR044Phh2DXY+55o7uJ0V+hYZAcQYSuFWsc9q5PvyDHUSCe1Qxn/iBz+78s86zWnGag==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/prompts": { "version": "2.4.2", "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", @@ -5540,16 +5786,6 @@ "node": ">= 6" } }, - "node_modules/pump": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz", - "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==", - "dev": true, - "dependencies": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, "node_modules/punycode": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", @@ -5608,14 +5844,14 @@ } }, "node_modules/regexp.prototype.flags": { - "version": "1.4.3", - "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz", - "integrity": "sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==", + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.1.tgz", + "integrity": "sha512-sy6TXMN+hnP/wMy+ISxg3krXx7BAtWVO4UouuCN/ziM9UEne0euamVNafDfvC83bRNr95y0V5iijeDQFUNpvrg==", "dev": true, "dependencies": { "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "functions-have-names": "^1.2.2" + "define-properties": "^1.2.0", + "set-function-name": "^2.0.0" }, "engines": { "node": ">= 0.4" @@ -5624,18 +5860,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/regexpp": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz", - "integrity": "sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==", - "dev": true, - "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/sponsors/mysticatea" - } - }, "node_modules/require-directory": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", @@ -5764,21 +5988,86 @@ "tslib": "^2.1.0" } }, - "node_modules/rxjs/node_modules/tslib": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz", - "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==", + "node_modules/safe-array-concat": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.0.tgz", + "integrity": "sha512-ZdQ0Jeb9Ofti4hbt5lX3T2JcAamT9hfzYU1MNB+z/jaEbB6wfFfPIR/zEORmZqobkCCJhSjodobH6WHNmJ97dg==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.5", + "get-intrinsic": "^1.2.2", + "has-symbols": "^1.0.3", + "isarray": "^2.0.5" + }, + "engines": { + "node": ">=0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-array-concat/node_modules/isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", "dev": true }, + "node_modules/safe-regex-test": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.2.tgz", + "integrity": "sha512-83S9w6eFq12BBIJYvjMux6/dkirb8+4zJRA9cxNBVb7Wq5fJBW+Xze48WqR8pxua7bDuAaaAxtVVd4Idjp1dBQ==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.5", + "get-intrinsic": "^1.2.2", + "is-regex": "^1.1.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "dev": true, "bin": { "semver": "bin/semver.js" } }, + "node_modules/set-function-length": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.0.tgz", + "integrity": "sha512-4DBHDoyHlM1IRPGYcoxexgh67y4ueR53FKV1yyxwFMY7aCqcN/38M1+SwZ/qJQ8iLv7+ck385ot4CcisOAPT9w==", + "dev": true, + "dependencies": { + "define-data-property": "^1.1.1", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.2", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/set-function-name": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.1.tgz", + "integrity": "sha512-tMNCiqYVkXIZgc2Hnoy2IvC/f8ezc5koaRFkCjrpWzGpCd3qbZXPzVy9MAZzK1ch/X0jvSkojys3oqJN0qCmdA==", + "dev": true, + "dependencies": { + "define-data-property": "^1.0.1", + "functions-have-names": "^1.2.3", + "has-property-descriptors": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/shebang-command": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", @@ -5970,29 +6259,46 @@ "node": ">=8" } }, + "node_modules/string.prototype.trim": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.8.tgz", + "integrity": "sha512-lfjY4HcixfQXOfaqCvcBuOIapyaroTXhbkfJN3gcB1OtyupngWK4sEET9Knd0cXd28kTUqu/kHoV4HKSJdnjiQ==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/string.prototype.trimend": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.5.tgz", - "integrity": "sha512-I7RGvmjV4pJ7O3kdf+LXFpVfdNOxtCW/2C8f6jNiW4+PQchwxkCDzlk1/7p+Wl4bqFIZeF47qAHXLuHHWKAxog==", + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.7.tgz", + "integrity": "sha512-Ni79DqeB72ZFq1uH/L6zJ+DKZTkOtPIHovb3YZHQViE+HDouuU4mBrLOLDn5Dde3RF8qw5qVETEjhu9locMLvA==", "dev": true, "dependencies": { "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "es-abstract": "^1.19.5" + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/string.prototype.trimstart": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.5.tgz", - "integrity": "sha512-THx16TJCGlsN0o6dl2o6ncWUsdgnLRSA23rRE5pyGBw/mLr3Ej/R2LaqCtgP8VNMGZsvMWnf9ooZPyY2bHvUFg==", + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.7.tgz", + "integrity": "sha512-NGhtDFu3jCEm7B4Fy0DpLewdJQOZcQ0rGbwQ/+stjnrp2i+rlKeCvos9hOIeCmqwratM47OBxY7uFZzjxHXmrg==", "dev": true, "dependencies": { "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "es-abstract": "^1.19.5" + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -6064,6 +6370,22 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/synckit": { + "version": "0.8.8", + "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.8.8.tgz", + "integrity": "sha512-HwOKAP7Wc5aRGYdKH+dw0PRRpbO841v2DENBtjnR5HFWoiNByAl7vrx3p0G/rCyYXQsrxqtX48TImFtPcIHSpQ==", + "dev": true, + "dependencies": { + "@pkgr/core": "^0.1.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/unts" + } + }, "node_modules/test-exclude": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", @@ -6126,6 +6448,18 @@ "node": ">=8.0" } }, + "node_modules/ts-api-utils": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.0.3.tgz", + "integrity": "sha512-wNMeqtMz5NtwpT/UZGY5alT+VoKdSsOOP/kqHFcUW1P/VRhH2wJ48+DN2WwUliNbQ976ETwDL0Ifd2VVvgonvg==", + "dev": true, + "engines": { + "node": ">=16.13.0" + }, + "peerDependencies": { + "typescript": ">=4.2.0" + } + }, "node_modules/ts-jest": { "version": "29.0.3", "resolved": "https://registry.npmjs.org/ts-jest/-/ts-jest-29.0.3.tgz", @@ -6185,13 +6519,13 @@ } }, "node_modules/tsconfig-paths": { - "version": "3.14.1", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.1.tgz", - "integrity": "sha512-fxDhWnFSLt3VuTwtvJt5fpwxBHg5AdKWMsgcPOOIilyjymcYVZoCQF8fvFRezCNfblEXmi+PcM1eYHeOAgXCOQ==", + "version": "3.15.0", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz", + "integrity": "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==", "dev": true, "dependencies": { "@types/json5": "^0.0.29", - "json5": "^1.0.1", + "json5": "^1.0.2", "minimist": "^1.2.6", "strip-bom": "^3.0.0" } @@ -6211,31 +6545,28 @@ "node_modules/tsconfig-paths/node_modules/strip-bom": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", "dev": true, "engines": { "node": ">=4" } }, "node_modules/tslib": { - "version": "1.14.1", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", - "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz", + "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==", "dev": true }, - "node_modules/tsutils": { - "version": "3.21.0", - "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz", - "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==", + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", "dev": true, "dependencies": { - "tslib": "^1.8.1" + "prelude-ls": "^1.2.1" }, "engines": { - "node": ">= 6" - }, - "peerDependencies": { - "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta" + "node": ">= 0.8.0" } }, "node_modules/type-detect": { @@ -6247,6 +6578,83 @@ "node": ">=4" } }, + "node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typed-array-buffer": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.0.tgz", + "integrity": "sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.1", + "is-typed-array": "^1.1.10" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/typed-array-byte-length": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.0.tgz", + "integrity": "sha512-Or/+kvLxNpeQ9DtSydonMxCx+9ZXOswtwJn17SNLvhptaXYDJvkFFP5zbfU/uLmvnBJlI4yrnXRxpdWH/M5tNA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "has-proto": "^1.0.1", + "is-typed-array": "^1.1.10" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-byte-offset": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.0.tgz", + "integrity": "sha512-RD97prjEt9EL8YgAgpOkf3O4IF9lhJFr9g0htQkm0rchFp/Vx7LW5Q8fSXXub7BXAODyUQohRMyOc3faCPd0hg==", + "dev": true, + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "has-proto": "^1.0.1", + "is-typed-array": "^1.1.10" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-length": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", + "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "is-typed-array": "^1.1.9" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/typedoc": { "version": "0.25.7", "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.25.7.tgz", @@ -6293,16 +6701,16 @@ } }, "node_modules/typescript": { - "version": "4.9.4", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.4.tgz", - "integrity": "sha512-Uz+dTXYzxXXbsFpM86Wh3dKCxrQqUcVMxwU54orwlJjOpO3ao8L7j5lH+dWfTwgCwIuM9GQ2kvVotzYJMXTBZg==", + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz", + "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==", "dev": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" }, "engines": { - "node": ">=4.2.0" + "node": ">=14.17" } }, "node_modules/unbox-primitive": { @@ -6355,12 +6763,6 @@ "punycode": "^2.1.0" } }, - "node_modules/v8-compile-cache": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz", - "integrity": "sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==", - "dev": true - }, "node_modules/v8-to-istanbul": { "version": "9.0.1", "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.0.1.tgz", @@ -6433,13 +6835,23 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/word-wrap": { - "version": "1.2.3", - "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", - "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==", + "node_modules/which-typed-array": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.14.tgz", + "integrity": "sha512-VnXFiIW8yNn9kIHN88xvZ4yOWchftKDsRJ8fEPacX/wl1lOvBrhsJ/OeJCXq7B0AaijRuqgzSKalJoPk+D8MPg==", "dev": true, + "dependencies": { + "available-typed-arrays": "^1.0.6", + "call-bind": "^1.0.5", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.1" + }, "engines": { - "node": ">=0.10.0" + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" } }, "node_modules/wrap-ansi": { diff --git a/package.json b/package.json index 3dffe08..b305ba2 100644 --- a/package.json +++ b/package.json @@ -39,24 +39,24 @@ "@types/debug": "^4.1.7", "@types/ini": "^1.3.30", "@types/jest": "^29.2.4", - "@typescript-eslint/eslint-plugin": "^5.26.0", - "@typescript-eslint/parser": "^5.26.0", - "eslint": "^8.16.0", + "@typescript-eslint/eslint-plugin": "^6.20.0", + "@typescript-eslint/parser": "^6.20.0", + "eslint": "^8.56.0", "eslint-config-airbnb-base": "^15.0.0", - "eslint-config-airbnb-typescript": "^17.0.0", - "eslint-config-prettier": "^8.5.0", - "eslint-plugin-import": "^2.26.0", - "eslint-plugin-prettier": "^4.0.0", - "eslint-plugin-simple-import-sort": "^7.0.0", + "eslint-config-airbnb-typescript": "^17.1.0", + "eslint-config-prettier": "^9.1.0", + "eslint-plugin-import": "^2.29.1", + "eslint-plugin-prettier": "^5.1.3", + "eslint-plugin-simple-import-sort": "^10.0.0", "eslint-plugin-tsdoc": "^0.2.17", "husky": "^8.0.1", "jest": "^29.3.1", "lint-staged": "^12.4.2", - "prettier": "^2.6.2", - "pretty-quick": "^3.1.0", + "prettier": "^3.2.5", + "pretty-quick": "^4.0.0", "ts-jest": "^29.0.3", - "typedoc": "^0.25.4", - "typescript": "^4.9.4" + "typedoc": "^0.25.7", + "typescript": "^5.3.3" }, "dependencies": { "@types/node": "*", From bc5cb26a67af0a8cdb6ce3708358591961e50a70 Mon Sep 17 00:00:00 2001 From: Even Rognlien Date: Sun, 4 Feb 2024 14:31:21 +0100 Subject: [PATCH 08/12] Rewrite SimulationsVariablesHelper to support both predefined (autogenerated from msfs docs) and custom simvars --- generated/simvars.ts | 9872 ++++++++++++++++++++ samples/typescript/apiHelper.ts | 56 +- src/ApiHelper/SimulationVariablesHelper.ts | 246 +- src/index.ts | 1 + 4 files changed, 10053 insertions(+), 122 deletions(-) create mode 100644 generated/simvars.ts diff --git a/generated/simvars.ts b/generated/simvars.ts new file mode 100644 index 0000000..0fba4ea --- /dev/null +++ b/generated/simvars.ts @@ -0,0 +1,9872 @@ +import { SimConnectDataType } from '../src/enums/SimConnectDataType'; + +export type PredefinedVariable = { + name: string; + units: string; + dataType: SimConnectDataType; + settable: boolean; +}; + +export const simvarPredefinitions = { + /** Currently not used within the simulation. */ + AUTOPILOT_AIRSPEED_ACQUISITION: { + name: 'AUTOPILOT AIRSPEED ACQUISITION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** returns whether airspeed hold is active (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_AIRSPEED_HOLD: { + name: 'AUTOPILOT AIRSPEED HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Currently not used within the simulation. */ + AUTOPILOT_AIRSPEED_HOLD_CURRENT: { + name: 'AUTOPILOT AIRSPEED HOLD CURRENT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the target holding airspeed for the autopilot. */ + AUTOPILOT_AIRSPEED_HOLD_VAR: { + name: 'AUTOPILOT AIRSPEED HOLD VAR', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the maximum calculated airspeed (kcas) limit set for the autopilot. */ + AUTOPILOT_AIRSPEED_MAX_CALCULATED: { + name: 'AUTOPILOT AIRSPEED MAX CALCULATED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the minimum calculated airspeed (kcas) limit set for the autopilot. */ + AUTOPILOT_AIRSPEED_MIN_CALCULATED: { + name: 'AUTOPILOT AIRSPEED MIN CALCULATED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** If enabled the Autopilot will use the Radio Altitude rather than the Indicated Altitude. */ + AUTOPILOT_ALT_RADIO_MODE: { + name: 'AUTOPILOT ALT RADIO MODE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the autopilot is in Altitude Arm mode (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_ALTITUDE_ARM: { + name: 'AUTOPILOT ALTITUDE ARM', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Altitude hold active */ + AUTOPILOT_ALTITUDE_LOCK: { + name: 'AUTOPILOT ALTITUDE LOCK', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Set or get the slot index which the altitude hold mode will track when captured. See alt_mode_slot_index for more information. */ + AUTOPILOT_ALTITUDE_LOCK_VAR: { + name: 'AUTOPILOT ALTITUDE LOCK VAR', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Whether or not the autopilot altitude is manually tunable or not. */ + AUTOPILOT_ALTITUDE_MANUALLY_TUNABLE: { + name: 'AUTOPILOT ALTITUDE MANUALLY TUNABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Index of the slot that the autopilot will use for the altitude reference. Note that there are 3 slots (1, 2, 3) that you can set/get normally, however you can also target slot index 0. Writing to slot 0 will overwrite all other slots with the slot 0 value, and by default the autopilot will follow slot 0 if you have not selected any slot index. + See alt_mode_slot_index for more information. */ + AUTOPILOT_ALTITUDE_SLOT_INDEX: { + name: 'AUTOPILOT ALTITUDE SLOT INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** When true, the autopilot is currently flying the approach Flight Plan (the last legs). */ + AUTOPILOT_APPROACH_ACTIVE: { + name: 'AUTOPILOT APPROACH ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns true when the autopilot is active on the approach, once it reaches the adequate condition (in most cases, once it reaches the second-last waypoint of the flightplan). */ + AUTOPILOT_APPROACH_ARM: { + name: 'AUTOPILOT APPROACH ARM', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns true when the lateral NAV mode is engaged and the angular deviation with the current tuned navigation frequency is less than 5°. */ + AUTOPILOT_APPROACH_CAPTURED: { + name: 'AUTOPILOT APPROACH CAPTURED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether pproach mode is active (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_APPROACH_HOLD: { + name: 'AUTOPILOT APPROACH HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns true if the current approach is using a localizer. */ + AUTOPILOT_APPROACH_IS_LOCALIZER: { + name: 'AUTOPILOT APPROACH IS LOCALIZER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Attitude hold active */ + AUTOPILOT_ATTITUDE_HOLD: { + name: 'AUTOPILOT ATTITUDE HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Available flag */ + AUTOPILOT_AVAILABLE: { + name: 'AUTOPILOT AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the autopilot has active managed avionics (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_AVIONICS_MANAGED: { + name: 'AUTOPILOT AVIONICS MANAGED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the autopilot back course mode is active (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_BACKCOURSE_HOLD: { + name: 'AUTOPILOT BACKCOURSE HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the autopilot bank hold mode is active (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_BANK_HOLD: { + name: 'AUTOPILOT BANK HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The current bank-hold bank reference. + Note that if you set this, the next frame the value will be overwritten by the engine, so you may need to write to this every game frame to ensure it maintains the required value. */ + AUTOPILOT_BANK_HOLD_REF: { + name: 'AUTOPILOT BANK HOLD REF', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Currently not used within the simulation. */ + AUTOPILOT_CRUISE_SPEED_HOLD: { + name: 'AUTOPILOT CRUISE SPEED HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The current default pitch mode of the autopilot as configured in the plane configuration with the parameter default_pitch_mode. */ + AUTOPILOT_DEFAULT_PITCH_MODE: { + name: 'AUTOPILOT DEFAULT PITCH MODE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The current default roll mode of the autopilot as configured in the plane configuration with the parameter default_bank_mode. */ + AUTOPILOT_DEFAULT_ROLL_MODE: { + name: 'AUTOPILOT DEFAULT ROLL MODE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the autopilot has been disengaged (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_DISENGAGED: { + name: 'AUTOPILOT DISENGAGED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Flight director active */ + AUTOPILOT_FLIGHT_DIRECTOR_ACTIVE: { + name: 'AUTOPILOT FLIGHT DIRECTOR ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Reference bank angle */ + AUTOPILOT_FLIGHT_DIRECTOR_BANK: { + name: 'AUTOPILOT FLIGHT DIRECTOR BANK', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Raw reference bank angle */ + AUTOPILOT_FLIGHT_DIRECTOR_BANK_EX1: { + name: 'AUTOPILOT FLIGHT DIRECTOR BANK EX1', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Reference pitch angle */ + AUTOPILOT_FLIGHT_DIRECTOR_PITCH: { + name: 'AUTOPILOT FLIGHT DIRECTOR PITCH', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Raw reference pitch angle */ + AUTOPILOT_FLIGHT_DIRECTOR_PITCH_EX1: { + name: 'AUTOPILOT FLIGHT DIRECTOR PITCH EX1', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Boolean, toggles the autopilot Flight Level Change mode */ + AUTOPILOT_FLIGHT_LEVEL_CHANGE: { + name: 'AUTOPILOT FLIGHT LEVEL CHANGE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** When true, the autopilot is receiving a signal from the runway beacon and is following the slope to reach the ground. */ + AUTOPILOT_GLIDESLOPE_ACTIVE: { + name: 'AUTOPILOT GLIDESLOPE ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns true when the autopilot is active on the glide slope. */ + AUTOPILOT_GLIDESLOPE_ARM: { + name: 'AUTOPILOT GLIDESLOPE ARM', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the autopilot glidslope hold is active (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_GLIDESLOPE_HOLD: { + name: 'AUTOPILOT GLIDESLOPE HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the autopilot heading lock is enabled (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_HEADING_LOCK: { + name: 'AUTOPILOT HEADING LOCK', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Specifies / Returns the locked in heading for the autopilot. */ + AUTOPILOT_HEADING_LOCK_DIR: { + name: 'AUTOPILOT HEADING LOCK DIR', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Whether or not the autopilot heading is manually tunable or not. */ + AUTOPILOT_HEADING_MANUALLY_TUNABLE: { + name: 'AUTOPILOT HEADING MANUALLY TUNABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Index of the slot that the autopilot will use for the heading reference. Note that there are 3 slots (1, 2, 3) that you can set/get normally, however you can also target slot index 0. Writing to slot 0 will overwrite all other slots with the slot 0 value, and by default the autopilot will follow slot 0 if you have not selected any slot index. */ + AUTOPILOT_HEADING_SLOT_INDEX: { + name: 'AUTOPILOT HEADING SLOT INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Mach hold active */ + AUTOPILOT_MACH_HOLD: { + name: 'AUTOPILOT MACH HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the target holding mach airspeed +for the autopilot. */ + AUTOPILOT_MACH_HOLD_VAR: { + name: 'AUTOPILOT MACH HOLD VAR', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Currently not used within the simulation. */ + AUTOPILOT_MANAGED_INDEX: { + name: 'AUTOPILOT MANAGED INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns whether the managed speed is in mach (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_MANAGED_SPEED_IN_MACH: { + name: 'AUTOPILOT MANAGED SPEED IN MACH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the autopilot managed throttle is active (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_MANAGED_THROTTLE_ACTIVE: { + name: 'AUTOPILOT MANAGED THROTTLE ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** On/off flag */ + AUTOPILOT_MASTER: { + name: 'AUTOPILOT MASTER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the maximum banking angle for the autopilot, in radians. */ + AUTOPILOT_MAX_BANK: { + name: 'AUTOPILOT MAX BANK', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the index of the current maximum bank setting of the autopilot. */ + AUTOPILOT_MAX_BANK_ID: { + name: 'AUTOPILOT MAX BANK ID', + units: 'Integer', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Currently not used within the simulation. */ + AUTOPILOT_MAX_SPEED_HOLD: { + name: 'AUTOPILOT MAX SPEED HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns TRUE (1) if the autopilot Nav1 lock is applied, or 0 (FALSE) otherwise. */ + AUTOPILOT_NAV1_LOCK: { + name: 'AUTOPILOT NAV1 LOCK', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Index of Nav radio selected */ + AUTOPILOT_NAV_SELECTED: { + name: 'AUTOPILOT NAV SELECTED', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Set to True if the autopilot pitch hold has is engaged. */ + AUTOPILOT_PITCH_HOLD: { + name: 'AUTOPILOT PITCH HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the current autotpilot reference pitch. */ + AUTOPILOT_PITCH_HOLD_REF: { + name: 'AUTOPILOT PITCH HOLD REF', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if autopilot rpm hold applied */ + AUTOPILOT_RPM_HOLD: { + name: 'AUTOPILOT RPM HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Selected rpm */ + AUTOPILOT_RPM_HOLD_VAR: { + name: 'AUTOPILOT RPM HOLD VAR', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Index of the slot that the autopilot will use for the RPM reference. Note that there are 3 slots (1, 2, 3) that you can set/get normally, however you can also target slot index 0. Writing to slot 0 will overwrite all other slots with the slot 0 value, and by default the autopilot will follow slot 0 if you have not selected any slot index. */ + AUTOPILOT_RPM_SLOT_INDEX: { + name: 'AUTOPILOT RPM SLOT INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Currently not used within the simulation. */ + AUTOPILOT_SPEED_SETTING: { + name: 'AUTOPILOT SPEED SETTING', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Index of the managed references */ + AUTOPILOT_SPEED_SLOT_INDEX: { + name: 'AUTOPILOT SPEED SLOT INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Takeoff / Go Around power mode active */ + AUTOPILOT_TAKEOFF_POWER_ACTIVE: { + name: 'AUTOPILOT TAKEOFF POWER ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the autopilot auto-throttle is armed (1, TRUE) or not (0, FALSE). */ + AUTOPILOT_THROTTLE_ARM: { + name: 'AUTOPILOT THROTTLE ARM', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This can be used to set/get the thrust lever position for autopilot maximum thrust. */ + AUTOPILOT_THROTTLE_MAX_THRUST: { + name: 'AUTOPILOT THROTTLE MAX THRUST', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if autopilot vertical hold applied */ + AUTOPILOT_VERTICAL_HOLD: { + name: 'AUTOPILOT VERTICAL HOLD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Selected vertical speed */ + AUTOPILOT_VERTICAL_HOLD_VAR: { + name: 'AUTOPILOT VERTICAL HOLD VAR', + units: 'Feet (ft)/minute', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Index of the slot that the autopilot will use for the VS reference. Note that there are 3 slots (1, 2, 3) that you can set/get normally, however you can also target slot index 0. Writing to slot 0 will overwrite all other slots with the slot 0 value, and by default the autopilot will follow slot 0 if you have not selected any slot index. */ + AUTOPILOT_VS_SLOT_INDEX: { + name: 'AUTOPILOT VS SLOT INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Wing leveler active */ + AUTOPILOT_WING_LEVELER: { + name: 'AUTOPILOT WING LEVELER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Yaw damper active */ + AUTOPILOT_YAW_DAMPER: { + name: 'AUTOPILOT YAW DAMPER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether landing assistance has been enabled or not. */ + ASSISTANCE_LANDING_ENABLED: { + name: 'ASSISTANCE LANDING ENABLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether takeoff assistance has been enabled or not. */ + ASSISTANCE_TAKEOFF_ENABLED: { + name: 'ASSISTANCE TAKEOFF ENABLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The current state of the AI anti-stall system. */ + AI_ANTISTALL_STATE: { + name: 'AI ANTISTALL STATE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the AI auto-trim system is enabled or not. */ + AI_AUTOTRIM_ACTIVE: { + name: 'AI AUTOTRIM ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the AI auto-trim system is enabled or not for AI controlled aircraft. */ + AI_AUTOTRIM_ACTIVE_AGAINST_PLAYER: { + name: 'AI AUTOTRIM ACTIVE AGAINST PLAYER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the AI control system is enabled or not. */ + AI_CONTROLS: { + name: 'AI CONTROLS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the AI cursor mode is active or not. */ + AI_CURSOR_MODE_ACTIVE: { + name: 'AI CURSOR MODE ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** AI reference pitch reference bars */ + ATTITUDE_BARS_POSITION: { + name: 'ATTITUDE BARS POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** AI caged state */ + ATTITUDE_CAGE: { + name: 'ATTITUDE CAGE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** AI bank indication */ + ATTITUDE_INDICATOR_BANK_DEGREES: { + name: 'ATTITUDE INDICATOR BANK DEGREES', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** AI pitch indication */ + ATTITUDE_INDICATOR_PITCH_DEGREES: { + name: 'ATTITUDE INDICATOR PITCH DEGREES', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns whether the AI control system is active or not. */ + DELEGATE_CONTROLS_TO_AI: { + name: 'DELEGATE CONTROLS TO AI', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** When set with any value this will cancel the current flight assistant destination. */ + FLY_ASSISTANT_CANCEL_DESTINATION: { + name: 'FLY ASSISTANT CANCEL DESTINATION', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** When set with any value this will cancel the display of the current flight assistant destination. */ + FLY_ASSISTANT_CANCEL_DESTINATION_DISPLAY: { + name: 'FLY ASSISTANT CANCEL DESTINATION DISPLAY', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns true when the copilot AI control is active and therefore COM AI is locked on active too. */ + FLY_ASSISTANT_COM_AI_LOCKED: { + name: 'FLY ASSISTANT COM AI LOCKED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns true when a destination has been set in the flight assistant. */ + FLY_ASSISTANT_HAVE_DESTINATION: { + name: 'FLY ASSISTANT HAVE DESTINATION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the POH range or an estimated value for this speed. */ + FLY_ASSISTANT_LANDING_SPEED: { + name: 'FLY ASSISTANT LANDING SPEED', + units: 'String', + dataType: SimConnectDataType.STRING32, + settable: false, + }, + /** Returns the display mode of the speed, CSS side (only STALL SPEED is working and will turn red when below). */ + FLY_ASSISTANT_LANDING_SPEED_DISPLAY_MODE: { + name: 'FLY ASSISTANT LANDING SPEED DISPLAY MODE', + units: 'String', + dataType: SimConnectDataType.STRING32, + settable: false, + }, + /** Selected category */ + FLY_ASSISTANT_NEAREST_CATEGORY: { + name: 'FLY ASSISTANT NEAREST CATEGORY', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Number of elements in this category */ + FLY_ASSISTANT_NEAREST_COUNT: { + name: 'FLY ASSISTANT NEAREST COUNT', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Currently not used within the simulation. */ + FLY_ASSISTANT_NEAREST_METADATA: { + name: 'FLY ASSISTANT NEAREST METADATA', + units: '-', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the name of the element at the specified index. */ + FLY_ASSISTANT_NEAREST_NAME: { + name: 'FLY ASSISTANT NEAREST NAME', + units: 'String', + dataType: SimConnectDataType.STRING256, + settable: false, + }, + /** Returns the index of the currently selected element. */ + FLY_ASSISTANT_NEAREST_SELECTED: { + name: 'FLY ASSISTANT NEAREST SELECTED', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns true when both ribbon assistances are active (taxi and landing), and can also be used to set them. */ + FLY_ASSISTANT_RIBBONS_ACTIVE: { + name: 'FLY ASSISTANT RIBBONS ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** When set with any value, it will set the selected element as the current destination. */ + FLY_ASSISTANT_SET_AS_DESTINATION: { + name: 'FLY ASSISTANT SET AS DESTINATION', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns the flight assistant stall speed. */ + FLY_ASSISTANT_STALL_SPEED: { + name: 'FLY ASSISTANT STALL SPEED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns the flight assistant stall speed display mode. */ + FLY_ASSISTANT_STALL_SPEED_DISPLAY_MODE: { + name: 'FLY ASSISTANT STALL SPEED DISPLAY MODE', + units: 'String', + dataType: SimConnectDataType.STRING32, + settable: false, + }, + /** Returns the flight assistant takeoff speed. */ + FLY_ASSISTANT_TAKEOFF_SPEED: { + name: 'FLY ASSISTANT TAKEOFF SPEED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns the flight assistant takeoff speed display mode. */ + FLY_ASSISTANT_TAKEOFF_SPEED_DISPLAY_MODE: { + name: 'FLY ASSISTANT TAKEOFF SPEED DISPLAY MODE', + units: 'String', + dataType: SimConnectDataType.STRING32, + settable: false, + }, + /** Can be set to override the estimated takeoff speed */ + FLY_ASSISTANT_TAKEOFF_SPEED_ESTIMATED: { + name: 'FLY ASSISTANT TAKEOFF SPEED ESTIMATED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if antiskid brakes active. This can be set using the AntiSkidActive parameter. */ + ANTISKID_BRAKES_ACTIVE: { + name: 'ANTISKID BRAKES ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the AutoBrakes are currently active. */ + AUTOBRAKES_ACTIVE: { + name: 'AUTOBRAKES ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Auto brake switch position */ + AUTO_BRAKE_SWITCH_CB: { + name: 'AUTO BRAKE SWITCH CB', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Brake dependent hydraulic pressure reading */ + BRAKE_DEPENDENT_HYDRAULIC_PRESSURE: { + name: 'BRAKE DEPENDENT HYDRAULIC PRESSURE', + units: 'Pounds per square foot (psf)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Brake on indication */ + BRAKE_INDICATOR: { + name: 'BRAKE INDICATOR', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent left brake. + Note that this SimVar no longer sets the right brake percent and simply triggers a brake pressure increase regardless of the value passed. */ + BRAKE_LEFT_POSITION: { + name: 'BRAKE LEFT POSITION', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Triggers a brake pressure increase on the left brake regardless of the value passed. */ + BRAKE_LEFT_POSITION_EX1: { + name: 'BRAKE LEFT POSITION EX1', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Parking brake indicator */ + BRAKE_PARKING_INDICATOR: { + name: 'BRAKE PARKING INDICATOR', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Gets the parking brake position - either on (true) or off (false). */ + BRAKE_PARKING_POSITION: { + name: 'BRAKE PARKING POSITION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent right brake. */ + BRAKE_RIGHT_POSITION: { + name: 'BRAKE RIGHT POSITION', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Triggers a brake pressure increase on the right brake regardless of the value passed. */ + BRAKE_RIGHT_POSITION_EX1: { + name: 'BRAKE RIGHT POSITION EX1', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Whether or not the rejected takeoff brakes are currently active. */ + REJECTED_TAKEOFF_BRAKES_ACTIVE: { + name: 'REJECTED TAKEOFF BRAKES ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if toe brakes are available */ + TOE_BRAKES_AVAILABLE: { + name: 'TOE BRAKES AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The percentage value representing the amount the contact point is compressed. Index is from 0-19. */ + 'CONTACT_POINT_COMPRESSION:index': { + name: 'CONTACT POINT COMPRESSION:index', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns true if the indexed contact point is on the ground, or will return false otherwise. Index is from 0 - 19. */ + 'CONTACT_POINT_IS_ON_GROUND:index': { + name: 'CONTACT POINT IS ON GROUND:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns true if the indexed contact point is skidding, or will return false otherwise. Index is from 0 - 19. */ + 'CONTACT_POINT_IS_SKIDDING:index': { + name: 'CONTACT POINT IS SKIDDING:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The currently extended position of the (retractable) contact point, expressed as a percentage. Index is from 0 - 19. */ + 'CONTACT_POINT_POSITION:index': { + name: 'CONTACT POINT POSITION:index', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The skidding factor associated with the indexed contact point, from 0 to 1. Index is from 0 - 19. */ + 'CONTACT_POINT_SKIDDING_FACTOR:index': { + name: 'CONTACT POINT SKIDDING FACTOR:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This returns the depth of the water for the indexed contact point. Index is from 0 - 19. */ + 'CONTACT_POINT_WATER_DEPTH:index': { + name: 'CONTACT POINT WATER DEPTH:index', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Aux wheel rotation angle (rotation around the axis for the wheel). */ + AUX_WHEEL_ROTATION_ANGLE: { + name: 'AUX WHEEL ROTATION ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Rpm of fourth set of gear wheels. */ + AUX_WHEEL_RPM: { + name: 'AUX WHEEL RPM', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Center wheel rotation angle (rotation around the axis for the wheel). + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + CENTER_WHEEL_ROTATION_ANGLE: { + name: 'CENTER WHEEL ROTATION ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Center landing gear rpm. */ + CENTER_WHEEL_RPM: { + name: 'CENTER WHEEL RPM', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent indexed gear animation extended. NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'GEAR_ANIMATION_POSITION:index': { + name: 'GEAR ANIMATION POSITION:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent auxiliary gear extended. */ + GEAR_AUX_POSITION: { + name: 'GEAR AUX POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Aux wheel angle, negative to the left, positive to the right. The aux wheel is the fourth set of landing gear, sometimes used on helicopters. */ + GEAR_AUX_STEER_ANGLE: { + name: 'GEAR AUX STEER ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Aux steer angle as a percentage. */ + GEAR_AUX_STEER_ANGLE_PCT: { + name: 'GEAR AUX STEER ANGLE PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent center gear extended. */ + GEAR_CENTER_POSITION: { + name: 'GEAR CENTER POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Center wheel angle, negative to the left, positive to the right. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + GEAR_CENTER_STEER_ANGLE: { + name: 'GEAR CENTER STEER ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Center steer angle as a percentage. */ + GEAR_CENTER_STEER_ANGLE_PCT: { + name: 'GEAR CENTER STEER ANGLE PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if gear has been damaged by excessive speed. */ + GEAR_DAMAGE_BY_SPEED: { + name: 'GEAR DAMAGE BY SPEED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if gear emergency handle applied. */ + GEAR_EMERGENCY_HANDLE_POSITION: { + name: 'GEAR EMERGENCY HANDLE POSITION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The gear handle position, where 0 means the handle is retracted and 1 is the handle fully applied. */ + GEAR_HANDLE_POSITION: { + name: 'GEAR HANDLE POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Gear hydraulic pressure. */ + GEAR_HYDRAULIC_PRESSURE: { + name: 'GEAR HYDRAULIC PRESSURE', + units: 'Pound force per square foot (psf)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the gear is on the ground. */ + 'GEAR_IS_ON_GROUND:index': { + name: 'GEAR IS ON GROUND:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the gear is skidding. */ + 'GEAR_IS_SKIDDING:index': { + name: 'GEAR IS SKIDDING:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent left gear extended. */ + GEAR_LEFT_POSITION: { + name: 'GEAR LEFT POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Left wheel angle, negative to the left, positive to the right. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + GEAR_LEFT_STEER_ANGLE: { + name: 'GEAR LEFT STEER ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Left steer angle as a percentage. */ + GEAR_LEFT_STEER_ANGLE_PCT: { + name: 'GEAR LEFT STEER ANGLE PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Position of landing gear. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'GEAR_POSITION:index': { + name: 'GEAR POSITION:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Percent right gear extended. */ + GEAR_RIGHT_POSITION: { + name: 'GEAR RIGHT POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Right wheel angle, negative to the left, positive to the right. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + GEAR_RIGHT_STEER_ANGLE: { + name: 'GEAR RIGHT STEER ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Right steer angle as a percentage. */ + GEAR_RIGHT_STEER_ANGLE_PCT: { + name: 'GEAR RIGHT STEER ANGLE PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The gear skidding factor, expressed as a value between 0 and 1. */ + GEAR_SKIDDING_FACTOR: { + name: 'GEAR SKIDDING FACTOR', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if safe speed limit for gear exceeded. */ + GEAR_SPEED_EXCEEDED: { + name: 'GEAR SPEED EXCEEDED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Alternative method of getting the steer angle. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'GEAR_STEER_ANGLE:index': { + name: 'GEAR STEER ANGLE:index', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Alternative method of getting steer angle as a percentage. */ + 'GEAR_STEER_ANGLE_PCT:index': { + name: 'GEAR STEER ANGLE PCT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent tail gear extended. + NOTE: This is a deprecated legacy SimVar and should not be used, as it will always return 0. */ + GEAR_TAIL_POSITION: { + name: 'GEAR TAIL POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent total gear extended. */ + GEAR_TOTAL_PCT_EXTENDED: { + name: 'GEAR TOTAL PCT EXTENDED', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Gear warnings. */ + 'GEAR_WARNING:index': { + name: 'GEAR WARNING:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The depth of the gear in the water. */ + GEAR_WATER_DEPTH: { + name: 'GEAR WATER DEPTH', + units: 'Centimeters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if landing gear are floats */ + IS_GEAR_FLOATS: { + name: 'IS GEAR FLOATS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if gear can be retracted */ + IS_GEAR_RETRACTABLE: { + name: 'IS GEAR RETRACTABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if landing gear is skids */ + IS_GEAR_SKIDS: { + name: 'IS GEAR SKIDS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if landing gear is skis */ + IS_GEAR_SKIS: { + name: 'IS GEAR SKIS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if landing gear is wheels */ + IS_GEAR_WHEELS: { + name: 'IS GEAR WHEELS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Left wheel rotation angle (rotation around the axis for the wheel). */ + LEFT_WHEEL_ROTATION_ANGLE: { + name: 'LEFT WHEEL ROTATION ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Left landing gear rpm */ + LEFT_WHEEL_RPM: { + name: 'LEFT WHEEL RPM', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the nosewheel lock is engaged. This can be set using the NosewheelLock parameter. */ + NOSEWHEEL_LOCK_ON: { + name: 'NOSEWHEEL LOCK ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Can be used to get or set the maximum permitted steering angle for the nose wheel of the aircraft. */ + NOSEWHEEL_MAX_STEERING_ANGLE: { + name: 'NOSEWHEEL MAX STEERING ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if retract float switch on */ + RETRACT_FLOAT_SWITCH: { + name: 'RETRACT FLOAT SWITCH', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** If aircraft has retractable floats. */ + RETRACT_LEFT_FLOAT_EXTENDED: { + name: 'RETRACT LEFT FLOAT EXTENDED', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** If aircraft has retractable floats. */ + RETRACT_RIGHT_FLOAT_EXTENDED: { + name: 'RETRACT RIGHT FLOAT EXTENDED', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Right wheel rotation angle (rotation around the axis for the wheel). */ + RIGHT_WHEEL_ROTATION_ANGLE: { + name: 'RIGHT WHEEL ROTATION ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Right landing gear rpm. */ + RIGHT_WHEEL_RPM: { + name: 'RIGHT WHEEL RPM', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Position of steering tiller. */ + STEER_INPUT_CONTROL: { + name: 'STEER INPUT CONTROL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if tailwheel lock applied. This can be set using the TailwheelLock parameter. */ + TAILWHEEL_LOCK_ON: { + name: 'TAILWHEEL LOCK ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent extended. */ + WATER_LEFT_RUDDER_EXTENDED: { + name: 'WATER LEFT RUDDER EXTENDED', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Water left rudder angle, negative to the left, positive to the right. */ + WATER_LEFT_RUDDER_STEER_ANGLE: { + name: 'WATER LEFT RUDDER STEER ANGLE', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Water left rudder angle as a percentage. */ + WATER_LEFT_RUDDER_STEER_ANGLE_PCT: { + name: 'WATER LEFT RUDDER STEER ANGLE PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent extended. */ + WATER_RIGHT_RUDDER_EXTENDED: { + name: 'WATER RIGHT RUDDER EXTENDED', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Water right rudder angle, negative to the left, positive to the right. */ + WATER_RIGHT_RUDDER_STEER_ANGLE: { + name: 'WATER RIGHT RUDDER STEER ANGLE', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Water right rudder as a percentage. */ + WATER_RIGHT_RUDDER_STEER_ANGLE_PCT: { + name: 'WATER RIGHT RUDDER STEER ANGLE PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Position of the water rudder handle (0 handle retracted, 1 rudder handle applied). */ + WATER_RUDDER_HANDLE_POSITION: { + name: 'WATER RUDDER HANDLE POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Wheel rotation angle (rotation around the axis for the wheel). */ + 'WHEEL_ROTATION_ANGLE:index': { + name: 'WHEEL ROTATION ANGLE:index', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Wheel rpm. */ + 'WHEEL_RPM:index': { + name: 'WHEEL RPM:index', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Angle deflection for the aileron. */ + AILERON_AVERAGE_DEFLECTION: { + name: 'AILERON AVERAGE DEFLECTION', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Angle deflection for the aileron. */ + AILERON_LEFT_DEFLECTION: { + name: 'AILERON LEFT DEFLECTION', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent deflection for the aileron. + NOTE: This is available in multiplayer to all near aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + AILERON_LEFT_DEFLECTION_PCT: { + name: 'AILERON LEFT DEFLECTION PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent aileron input left/right. */ + AILERON_POSITION: { + name: 'AILERON POSITION', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Angle deflection. */ + AILERON_RIGHT_DEFLECTION: { + name: 'AILERON RIGHT DEFLECTION', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent deflection. + NOTE: This is available in multiplayer to all near aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + AILERON_RIGHT_DEFLECTION_PCT: { + name: 'AILERON RIGHT DEFLECTION PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Angle deflection. */ + AILERON_TRIM: { + name: 'AILERON TRIM', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether or not the Aileron Trim has been disabled. */ + AILERON_TRIM_DISABLED: { + name: 'AILERON TRIM DISABLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The trim position of the ailerons. Zero is fully retracted. + NOTE: This is available in multiplayer to all near aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + AILERON_TRIM_PCT: { + name: 'AILERON TRIM PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Angle deflection. */ + ELEVATOR_DEFLECTION: { + name: 'ELEVATOR DEFLECTION', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent deflection. + NOTE: This is available in multiplayer. See here for more information: +Note On SimVars In Multiplayer. */ + ELEVATOR_DEFLECTION_PCT: { + name: 'ELEVATOR DEFLECTION PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent elevator input deflection. */ + ELEVATOR_POSITION: { + name: 'ELEVATOR POSITION', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Whether or not the Elevator Trim has been disabled. */ + ELEVATOR_TRIM_DISABLED: { + name: 'ELEVATOR TRIM DISABLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the maximum elevator trim value. This corresponds to the elevator_trim_down_limit in the Flight Model Config file. */ + ELEVATOR_TRIM_DOWN_LIMIT: { + name: 'ELEVATOR TRIM DOWN LIMIT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent elevator trim (for indication). */ + ELEVATOR_TRIM_INDICATOR: { + name: 'ELEVATOR TRIM INDICATOR', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Elevator trim neutral. */ + ELEVATOR_TRIM_NEUTRAL: { + name: 'ELEVATOR TRIM NEUTRAL', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent elevator trim. */ + ELEVATOR_TRIM_PCT: { + name: 'ELEVATOR TRIM PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Elevator trim deflection. */ + ELEVATOR_TRIM_POSITION: { + name: 'ELEVATOR TRIM POSITION', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns the maximum elevator trim value. This corresponds to the elevator_trim_up_limit in the Flight Model Config file. */ + ELEVATOR_TRIM_UP_LIMIT: { + name: 'ELEVATOR TRIM UP LIMIT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Elevon deflection. */ + ELEVON_DEFLECTION: { + name: 'ELEVON DEFLECTION', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if flaps are damaged by excessive speed. */ + FLAP_DAMAGE_BY_SPEED: { + name: 'FLAP DAMAGE BY SPEED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Set the position of the flaps control. */ + FLAP_POSITION_SET: { + name: 'FLAP POSITION SET', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if safe speed limit for flaps exceeded. */ + FLAP_SPEED_EXCEEDED: { + name: 'FLAP SPEED EXCEEDED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if flaps available. */ + FLAPS_AVAILABLE: { + name: 'FLAPS AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This returns the effective flaps handle index, after some of the conditions have potentially forced the state to change. */ + 'FLAPS_EFFECTIVE_HANDLE_INDEX:index': { + name: 'FLAPS EFFECTIVE HANDLE INDEX:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Index of current flap position. */ + 'FLAPS_HANDLE_INDEX:index': { + name: 'FLAPS HANDLE INDEX:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent flap handle extended. + NOTE: This is available in multiplayer +to all near aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + FLAPS_HANDLE_PERCENT: { + name: 'FLAPS HANDLE PERCENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Number of available flap positions. */ + FLAPS_NUM_HANDLE_POSITIONS: { + name: 'FLAPS NUM HANDLE POSITIONS', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Angle left leading edge flap extended. Use LEADING_EDGE_FLAPS_LEFT_PERCENT to set a value. */ + LEADING_EDGE_FLAPS_LEFT_ANGLE: { + name: 'LEADING EDGE FLAPS LEFT ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Index of left leading edge flap position. */ + LEADING_EDGE_FLAPS_LEFT_INDEX: { + name: 'LEADING EDGE FLAPS LEFT INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent left leading edge flap extended. + NOTE: This is available in multiplayer +to all near aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LEADING_EDGE_FLAPS_LEFT_PERCENT: { + name: 'LEADING EDGE FLAPS LEFT PERCENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Angle right leading edge flap extended. Use LEADING_EDGE_FLAPS_RIGHT_PERCENT to set a value. */ + LEADING_EDGE_FLAPS_RIGHT_ANGLE: { + name: 'LEADING EDGE FLAPS RIGHT ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Index of right leading edge flap position. */ + LEADING_EDGE_FLAPS_RIGHT_INDEX: { + name: 'LEADING EDGE FLAPS RIGHT INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent right leading edge flap extended. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LEADING_EDGE_FLAPS_RIGHT_PERCENT: { + name: 'LEADING EDGE FLAPS RIGHT PERCENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Angle left trailing edge flap extended. Use TRAILING_EDGE_FLAPS_LEFT_PERCENT to set a value. */ + TRAILING_EDGE_FLAPS_LEFT_ANGLE: { + name: 'TRAILING EDGE FLAPS LEFT ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Index of left trailing edge flap position. */ + TRAILING_EDGE_FLAPS_LEFT_INDEX: { + name: 'TRAILING EDGE FLAPS LEFT INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent left trailing edge flap extended. + NOTE: This is available in multiplayer +to all near aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + TRAILING_EDGE_FLAPS_LEFT_PERCENT: { + name: 'TRAILING EDGE FLAPS LEFT PERCENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Angle right trailing edge flap extended. Use TRAILING_EDGE_FLAPS_RIGHT_PERCENT to set a value. */ + TRAILING_EDGE_FLAPS_RIGHT_ANGLE: { + name: 'TRAILING EDGE FLAPS RIGHT ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Index of right trailing edge flap position. */ + TRAILING_EDGE_FLAPS_RIGHT_INDEX: { + name: 'TRAILING EDGE FLAPS RIGHT INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent right trailing edge flap extended. + NOTE: This is available in multiplayer +to all near aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + TRAILING_EDGE_FLAPS_RIGHT_PERCENT: { + name: 'TRAILING EDGE FLAPS RIGHT PERCENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns true if the fly-by-wire alpha protection is enabled or false otherwise. */ + FLY_BY_WIRE_ALPHA_PROTECTION: { + name: 'FLY BY WIRE ALPHA PROTECTION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the Elevators and Ailerons computer has failed. */ + FLY_BY_WIRE_ELAC_FAILED: { + name: 'FLY BY WIRE ELAC FAILED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the fly by wire Elevators and Ailerons computer is on. */ + FLY_BY_WIRE_ELAC_SWITCH: { + name: 'FLY BY WIRE ELAC SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the Flight Augmentation computer has failed. */ + FLY_BY_WIRE_FAC_FAILED: { + name: 'FLY BY WIRE FAC FAILED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the fly by wire Flight Augmentation computer is on. */ + FLY_BY_WIRE_FAC_SWITCH: { + name: 'FLY BY WIRE FAC SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the Spoilers and Elevators computer has failed. */ + FLY_BY_WIRE_SEC_FAILED: { + name: 'FLY BY WIRE SEC FAILED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the fly by wire Spoilers and Elevators computer is on. */ + FLY_BY_WIRE_SEC_SWITCH: { + name: 'FLY BY WIRE SEC SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the folding wing handle is engaged. */ + FOLDING_WING_HANDLE_POSITION: { + name: 'FOLDING WING HANDLE POSITION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Left folding wing position, 1.0 is fully folded. */ + FOLDING_WING_LEFT_PERCENT: { + name: 'FOLDING WING LEFT PERCENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Right folding wing position, 1.0 is fully folded. */ + FOLDING_WING_RIGHT_PERCENT: { + name: 'FOLDING WING RIGHT PERCENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Angle deflection. */ + RUDDER_DEFLECTION: { + name: 'RUDDER DEFLECTION', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent deflection. + NOTE: This is available in multiplayer. See here for more information: +Note On SimVars In Multiplayer. */ + RUDDER_DEFLECTION_PCT: { + name: 'RUDDER DEFLECTION PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Rudder pedal position. */ + RUDDER_PEDAL_INDICATOR: { + name: 'RUDDER PEDAL INDICATOR', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent rudder pedal deflection (for animation). */ + RUDDER_PEDAL_POSITION: { + name: 'RUDDER PEDAL POSITION', + units: 'Position (-16K to 0)', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent rudder input deflection. */ + RUDDER_POSITION: { + name: 'RUDDER POSITION', + units: 'Position (-16K to 0)', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Angle deflection. */ + RUDDER_TRIM: { + name: 'RUDDER TRIM', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether or not the Rudder Trim has been disabled. */ + RUDDER_TRIM_DISABLED: { + name: 'RUDDER TRIM DISABLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The trim position of the rudder. Zero is no trim. */ + RUDDER_TRIM_PCT: { + name: 'RUDDER TRIM PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Checks if autospoilers are armed (true) or not (false). */ + SPOILERS_ARMED: { + name: 'SPOILERS ARMED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if spoiler system available. */ + SPOILER_AVAILABLE: { + name: 'SPOILER AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Spoiler handle position. */ + SPOILERS_HANDLE_POSITION: { + name: 'SPOILERS HANDLE POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent left spoiler deflected. + NOTE: This is available in multiplayer. See here for more information: +Note On SimVars In Multiplayer. */ + SPOILERS_LEFT_POSITION: { + name: 'SPOILERS LEFT POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent right spoiler deflected. + NOTE: This is available in multiplayer. See here for more information: +Note On SimVars In Multiplayer. */ + SPOILERS_RIGHT_POSITION: { + name: 'SPOILERS RIGHT POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Indexed from 1, 100 is fully deployed, 0 flat on deck */ + 'BLAST_SHIELD_POSITION:index': { + name: 'BLAST SHIELD POSITION:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** A number 1 through 4 for the cable number caught by the tailhook. Cable 1 is the one closest to the stern of the carrier. A value of 0 indicates no cable was caught. */ + 'CABLE_CAUGHT_BY_TAILHOOK:index': { + name: 'CABLE CAUGHT BY TAILHOOK:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Catapults are indexed from 1. This value will be 0 before the catapult fires, and then up to 100 as the aircraft is propelled down the catapult. The aircraft may takeoff before the value reaches 100 (depending on the aircraft weight, power applied, and other factors), in which case this value will not be further updated. This value could be used to drive a bogie animation. */ + 'CATAPULT_STROKE_POSITION:index': { + name: 'CATAPULT STROKE POSITION:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Holdback bars allow build up of thrust before takeoff from a catapult, and are installed by the deck crew of an aircraft carrier. */ + HOLDBACK_BAR_INSTALLED: { + name: 'HOLDBACK BAR INSTALLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This will be True if the launchbar is fully extended, and can be used, for example, to change the color of an instrument light. */ + LAUNCHBAR_HELD_EXTENDED: { + name: 'LAUNCHBAR HELD EXTENDED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Installed on aircraft before takeoff from a carrier catapult. Note that gear cannot retract with this extended. 100 = fully extended. */ + LAUNCHBAR_POSITION: { + name: 'LAUNCHBAR POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** If this is set to True the launch bar switch has been engaged. */ + LAUNCHBAR_SWITCH: { + name: 'LAUNCHBAR SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Maximum of 4. A model can contain more than 4 catapults, but only the first four will be read and recognized by the simulation. */ + NUMBER_OF_CATAPULTS: { + name: 'NUMBER OF CATAPULTS', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The nose angle, where 0 is fully up. */ + CONCORDE_NOSE_ANGLE: { + name: 'CONCORDE NOSE ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The visor nose handle position. */ + CONCORDE_VISOR_NOSE_HANDLE: { + name: 'CONCORDE VISOR NOSE HANDLE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The visor position expressed as a percentage where 0.0 = up and 1.0 = extended/down. */ + CONCORDE_VISOR_POSITION_PERCENT: { + name: 'CONCORDE VISOR POSITION PERCENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This is a settable simvar meaning that it can both be read and set. Some of the simvars in this list are using this to lookup a value using two arguments (one argument in addition to the component index). For example to check the state of the connection between a "circuit.45" and the "bus.2" it would be written as follows: + 2 (>A:BUS LOOKUP INDEX, Number) (A:CIRCUIT CONNECTION ON:45, Bool) + It should be notes that when BUS_LOOKUP_INDEX is not set (ie: it is 0) then TRUE will be returned if any of your bus connections are on. */ + BUS_LOOKUP_INDEX: { + name: 'BUS LOOKUP INDEX', + units: '-', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This will be true if the bus breaker is pulled. Requires a BUS_LOOKUP_INDEX and a bus index. */ + BUS_BREAKER_PULLED: { + name: 'BUS BREAKER PULLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This will be true if the bus is connected. Requires a BUS_LOOKUP_INDEX and a bus index. */ + BUS_CONNECTION_ON: { + name: 'BUS CONNECTION ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This returns the percentage of the load output that is being consumed. This requires an alternator index when referencing. */ + ELECTRICAL_GENALT_LOAD: { + name: 'ELECTRICAL GENALT LOAD', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The load handled by the alternator. This requires an alternator index when referencing. */ + ELECTRICAL_GENALT_BUS_AMPS: { + name: 'ELECTRICAL GENALT BUS AMPS', + units: 'Amperes', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** General alternator voltage. This requires an alternator index when referencing. */ + ELECTRICAL_GENALT_BUS_VOLTAGE: { + name: 'ELECTRICAL GENALT BUS VOLTAGE', + units: 'Volts', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The main bus voltage. Use a bus index when referencing. */ + ELECTRICAL_MAIN_BUS_VOLTAGE: { + name: 'ELECTRICAL MAIN BUS VOLTAGE', + units: 'Volts', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Avionics bus current */ + ELECTRICAL_AVIONICS_BUS_AMPS: { + name: 'ELECTRICAL AVIONICS BUS AMPS', + units: 'Amperes', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Avionics bus voltage */ + ELECTRICAL_AVIONICS_BUS_VOLTAGE: { + name: 'ELECTRICAL AVIONICS BUS VOLTAGE', + units: 'Volts', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Main bus current */ + ELECTRICAL_MAIN_BUS_AMPS: { + name: 'ELECTRICAL MAIN BUS AMPS', + units: 'Amperes', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Deprecated, do not use! + Use ELECTRICAL BATTERY LOAD. */ + ELECTRICAL_OLD_CHARGING_AMPS: { + name: 'ELECTRICAL OLD CHARGING AMPS', + units: 'Amps', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Total load amps */ + ELECTRICAL_TOTAL_LOAD_AMPS: { + name: 'ELECTRICAL TOTAL LOAD AMPS', + units: 'Amperes', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Is the aircraft using the new Electrical System or the legacy FSX one. */ + NEW_ELECTRICAL_SYSTEM: { + name: 'NEW ELECTRICAL SYSTEM', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This will be true if the alternator breaker is pulled. Requires a BUS_LOOKUP_INDEX and an alternator index. */ + ALTERNATOR_BREAKER_PULLED: { + name: 'ALTERNATOR BREAKER PULLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This will be true if the alternator is connected. Requires a BUS_LOOKUP_INDEX and an alternator index. */ + ALTERNATOR_CONNECTION_ON: { + name: 'ALTERNATOR CONNECTION ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The alternator (generator) switch position, true if the switch is ON. Requires an engine index, and the use of an alternator index when referencing. */ + 'GENERAL_ENG_MASTER_ALTERNATOR:index': { + name: 'GENERAL ENG MASTER ALTERNATOR:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Bleed air pressure received by the engine from the APU. */ + APU_BLEED_PRESSURE_RECEIVED_BY_ENGINE: { + name: 'APU BLEED PRESSURE RECEIVED BY ENGINE', + units: 'Pounds per square inch (psi)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Set or get whether an APU is active (true) or not (false). Takes an index to be able to have multiple generators on a single APU. */ + 'APU_GENERATOR_ACTIVE:index': { + name: 'APU GENERATOR ACTIVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Enables or disables the APU for an engine. Takes an index to be able to have multiple generators on a single APU */ + 'APU_GENERATOR_SWITCH:index': { + name: 'APU GENERATOR SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Will return true if the APU is on fire, or false otherwise. */ + APU_ON_FIRE_DETECTED: { + name: 'APU ON FIRE DETECTED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Auxiliary power unit RPM, as a percentage */ + APU_PCT_RPM: { + name: 'APU PCT RPM', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Auxiliary power unit starter, as a percentage */ + APU_PCT_STARTER: { + name: 'APU PCT STARTER', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Boolean, whether or not the APU is switched on. */ + APU_SWITCH: { + name: 'APU SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The volts from the APU to the selected engine. Takes an index to be able to have multiple generators on a single APU. */ + 'APU_VOLTS:index': { + name: 'APU VOLTS:index', + units: 'Volts', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Boolean, returns whether or not the APU attempts to provide Bleed Air. */ + BLEED_AIR_APU: { + name: 'BLEED AIR APU', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This will be true if the battery breaker is pulled. Requires a BUS LOOKUP INDEX and a battery index. */ + BATTERY_BREAKER_PULLED: { + name: 'BATTERY BREAKER PULLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This will be true if the battery is connected. Requires a BUS_LOOKUP_INDEX and a battery index. */ + BATTERY_CONNECTION_ON: { + name: 'BATTERY CONNECTION ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Battery bus current */ + ELECTRICAL_BATTERY_BUS_AMPS: { + name: 'ELECTRICAL BATTERY BUS AMPS', + units: 'Amperes', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Battery bus voltage */ + ELECTRICAL_BATTERY_BUS_VOLTAGE: { + name: 'ELECTRICAL BATTERY BUS VOLTAGE', + units: 'Volts', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Battery capacity over max capacity, 100 is full. */ + ELECTRICAL_BATTERY_ESTIMATED_CAPACITY_PCT: { + name: 'ELECTRICAL BATTERY ESTIMATED CAPACITY PCT', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The load handled by the battery (negative values mean the battery is receiving current). Use a battery index when referencing. */ + ELECTRICAL_BATTERY_LOAD: { + name: 'ELECTRICAL BATTERY LOAD', + units: 'Amperes', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The battery voltage. Use a battery index when referencing. */ + ELECTRICAL_BATTERY_VOLTAGE: { + name: 'ELECTRICAL BATTERY VOLTAGE', + units: 'Volts', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current available when battery switch is turned off */ + ELECTRICAL_HOT_BATTERY_BUS_AMPS: { + name: 'ELECTRICAL HOT BATTERY BUS AMPS', + units: 'Amperes', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Voltage available when battery switch is turned off */ + ELECTRICAL_HOT_BATTERY_BUS_VOLTAGE: { + name: 'ELECTRICAL HOT BATTERY BUS VOLTAGE', + units: 'Volts', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The battery switch position, true if the switch is ON. Use a battery index when referencing. */ + ELECTRICAL_MASTER_BATTERY: { + name: 'ELECTRICAL MASTER BATTERY', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** All these SimVars can be used to get or set the breaker state for the electrical system (either true or false). + If the breaker is popped (set to false), then the associated circuit will not receive electricity. */ + BREAKER_ADF: { + name: 'BREAKER ADF', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Bool */ + BREAKER_ALTFLD: { + name: 'BREAKER ALTFLD', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_AUTOPILOT: { + name: 'BREAKER AUTOPILOT', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_AVNBUS1: { + name: 'BREAKER AVNBUS1', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_AVNBUS2: { + name: 'BREAKER AVNBUS2', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_AVNFAN: { + name: 'BREAKER AVNFAN', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_FLAP: { + name: 'BREAKER FLAP', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_GPS: { + name: 'BREAKER GPS', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_INST: { + name: 'BREAKER INST', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_INSTLTS: { + name: 'BREAKER INSTLTS', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_LTS_PWR: { + name: 'BREAKER LTS PWR', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Bool */ + BREAKER_NAVCOM1: { + name: 'BREAKER NAVCOM1', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_NAVCOM2: { + name: 'BREAKER NAVCOM2', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_NAVCOM3: { + name: 'BREAKER NAVCOM3', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_TURNCOORD: { + name: 'BREAKER TURNCOORD', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_WARN: { + name: 'BREAKER WARN', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Bool */ + BREAKER_XPNDR: { + name: 'BREAKER XPNDR', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Is electrical power available to this circuit */ + CIRCUIT_AUTOPILOT_ON: { + name: 'CIRCUIT AUTOPILOT ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to this circuit */ + CIRCUIT_AUTO_BRAKES_ON: { + name: 'CIRCUIT AUTO BRAKES ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to this circuit. Please see the +Note On Autofeathering for more information. */ + CIRCUIT_AUTO_FEATHER_ON: { + name: 'CIRCUIT AUTO FEATHER ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to this circuit */ + CIRCUIT_AVIONICS_ON: { + name: 'CIRCUIT AVIONICS ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This will be true if the circuit breaker is pulled. Requires a BUS_LOOKUP_INDEX and a circuit index. */ + CIRCUIT_BREAKER_PULLED: { + name: 'CIRCUIT BREAKER PULLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This will be true if the circuit is connected. Requires a BUS_LOOKUP_INDEX and a circuit index. */ + CIRCUIT_CONNECTION_ON: { + name: 'CIRCUIT CONNECTION ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to the flap motor circuit */ + CIRCUIT_FLAP_MOTOR_ON: { + name: 'CIRCUIT FLAP MOTOR ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to the gear motor circuit */ + CIRCUIT_GEAR_MOTOR_ON: { + name: 'CIRCUIT GEAR MOTOR ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to gear warning circuit */ + CIRCUIT_GEAR_WARNING_ON: { + name: 'CIRCUIT GEAR WARNING ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to the general panel circuit */ + CIRCUIT_GENERAL_PANEL_ON: { + name: 'CIRCUIT GENERAL PANEL ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to the hydraulic pump circuit */ + CIRCUIT_HYDRAULIC_PUMP_ON: { + name: 'CIRCUIT HYDRAULIC PUMP ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to the marker beacon circuit */ + CIRCUIT_MARKER_BEACON_ON: { + name: 'CIRCUIT MARKER BEACON ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not power is available to the NAVCOM1 circuit. */ + CIRCUIT_NAVCOM1_ON: { + name: 'CIRCUIT NAVCOM1 ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not power is available to the NAVCOM2 circuit. */ + CIRCUIT_NAVCOM2_ON: { + name: 'CIRCUIT NAVCOM2 ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not power is available to the NAVCOM3 circuit. */ + CIRCUIT_NAVCOM3_ON: { + name: 'CIRCUIT NAVCOM3 ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This will be true if the given circuit is functioning. Use a circuit index when referencing. */ + CIRCUIT_ON: { + name: 'CIRCUIT ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to the pitot heat circuit */ + CIRCUIT_PITOT_HEAT_ON: { + name: 'CIRCUIT PITOT HEAT ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This returns the percentage of use that the circuit is getting. This requires a circuit index when referencing. */ + CIRCUIT_POWER_SETTING: { + name: 'CIRCUIT POWER SETTING', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Is electrical power available to the propeller sync circuit */ + CIRCUIT_PROP_SYNC_ON: { + name: 'CIRCUIT PROP SYNC ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is electrical power available to the vacuum circuit */ + CIRCUIT_STANDBY_VACUUM_ON: { + name: 'CIRCUIT STANDBY VACUUM ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The circuit switch position, true if the switch is ON. Use a circuit index when referencing. */ + CIRCUIT_SWITCH_ON: { + name: 'CIRCUIT SWITCH ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This will be true if the given external power source is available. Use an external power index when referencing. */ + EXTERNAL_POWER_AVAILABLE: { + name: 'EXTERNAL POWER AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Boolean, The state of the breaker of an external power source */ + EXTERNAL_POWER_BREAKER_PULLED: { + name: 'EXTERNAL POWER BREAKER PULLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Boolean, The state of the connection between a bus and an external power source */ + EXTERNAL_POWER_CONNECTION_ON: { + name: 'EXTERNAL POWER CONNECTION ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The external power switch position, true if the switch is ON. Use an external power index when referencing. */ + EXTERNAL_POWER_ON: { + name: 'EXTERNAL POWER ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether or not the indexed engine (see note) attempts to provide bleed air. */ + 'BLEED_AIR_ENGINE:index': { + name: 'BLEED AIR ENGINE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The bleed air system source controller for an indexed engine (see note). This will work as follows: + + When engines and APU are activated, it will return 0 because it is in Auto. + If the APU is removed, it will return 3 for engines only. + If instead the engines are removed, it would return 2 for the APU only. + If the APU and engines are removed, it would return 1 (so, off). */ + 'BLEED_AIR_SOURCE_CONTROL:index': { + name: 'BLEED AIR SOURCE CONTROL:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Deprecated, do not use! */ + COWL_FLAPS: { + name: 'COWL FLAPS', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Selected engines (combination of bit flags) */ + ENGINE_CONTROL_SELECT: { + name: 'ENGINE CONTROL SELECT', + units: 'Flags:', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if engine mixture is available for prop engines. Deprecated, do not use (mixture is always available)! */ + ENGINE_MIXURE_AVAILABLE: { + name: 'ENGINE MIXURE AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The engine primer position. */ + ENGINE_PRIMER: { + name: 'ENGINE PRIMER', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Engine type. */ + ENGINE_TYPE: { + name: 'ENGINE TYPE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Anti-ice switch for the indexed engine (see note), true if enabled false otherwise. */ + 'ENG_ANTI_ICE:index': { + name: 'ENG ANTI ICE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the indexed engine (see note) is running, false otherwise. */ + 'ENG_COMBUSTION:index': { + name: 'ENG COMBUSTION:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The indexed engine (see note) cylinder head temperature. */ + 'ENG_CYLINDER_HEAD_TEMPERATURE:index': { + name: 'ENG CYLINDER HEAD TEMPERATURE:index', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Exhaust gas temperature for the indexed engine (see note). */ + 'ENG_EXHAUST_GAS_TEMPERATURE:index': { + name: 'ENG EXHAUST GAS TEMPERATURE:index', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Governed engine setting exhaust gas temperature for the indexed engine (see note). */ + 'ENG_EXHAUST_GAS_TEMPERATURE_GES:index': { + name: 'ENG EXHAUST GAS TEMPERATURE GES:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Failure flag for the indexed engine (see note) that has failed. */ + 'ENG_FAILED:index': { + name: 'ENG FAILED:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Fuel flow reference in pounds per hour for the indexed engine (see note). */ + 'ENG_FUEL_FLOW_BUG_POSITION:index': { + name: 'ENG FUEL FLOW BUG POSITION:index', + units: 'Pounds per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Engine fuel flow in gallons per hour for the indexed engine (see note). */ + 'ENG_FUEL_FLOW_GPH:index': { + name: 'ENG FUEL FLOW GPH:index', + units: 'Gallons per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) fuel flow in pounds per hour. */ + 'ENG_FUEL_FLOW_PPH:index': { + name: 'ENG FUEL FLOW PPH:index', + units: 'Pounds per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Engine fuel flow in pounds per hour. + Deprecated in favour of ENG FUEL FLOW PPH. */ + 'ENG_FUEL_FLOW_PPH_SSL:index': { + name: 'ENG FUEL FLOW PPH SSL:index', + units: 'Pounds per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) hydraulic pressure. */ + 'ENG_HYDRAULIC_PRESSURE:index': { + name: 'ENG HYDRAULIC PRESSURE:index', + units: 'Pounds per square foot (psf)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note)hydraulic fluid quantity, as a percentage of total capacity */ + 'ENG_HYDRAULIC_QUANTITY:index': { + name: 'ENG HYDRAULIC QUANTITY:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) manifold pressure. */ + 'ENG_MANIFOLD_PRESSURE:index': { + name: 'ENG MANIFOLD PRESSURE:index', + units: 'Inches of mercury (inHg)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) Maximum rpm. */ + ENG_MAX_RPM: { + name: 'ENG MAX RPM', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) N1 rpm. */ + 'ENG_N1_RPM:index': { + name: 'ENG N1 RPM:index', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) N2 rpm. */ + 'ENG_N2_RPM:index': { + name: 'ENG N2 RPM:index', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) oil pressure. */ + 'ENG_OIL_PRESSURE:index': { + name: 'ENG OIL PRESSURE:index', + units: 'pounds per square foot (psf)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) oil quantity as a percentage of full capacity. */ + 'ENG_OIL_QUANTITY:index': { + name: 'ENG OIL QUANTITY:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) oil temperature. */ + 'ENG_OIL_TEMPERATURE:index': { + name: 'ENG OIL TEMPERATURE:index', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) on fire state. */ + 'ENG_ON_FIRE:index': { + name: 'ENG ON FIRE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The indexed engine (see note) pressure ratio. */ + 'ENG_PRESSURE_RATIO:index': { + name: 'ENG PRESSURE RATIO:index', + units: 'Ratio', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Engine pressure ratio. Deprecated, do not use! */ + 'ENG_PRESSURE_RATIO_GES:index': { + name: 'ENG PRESSURE RATIO GES:index', + units: 'Scalar', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) percentage maximum rated rpm - used for visual animation. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'ENG_RPM_ANIMATION_PERCENT:index': { + name: 'ENG RPM ANIMATION PERCENT:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** RPM scalar value. Deprecated, do not use! */ + 'ENG_RPM_SCALER:index': { + name: 'ENG RPM SCALER:index', + units: 'Scalar', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) torque. */ + 'ENG_TORQUE:index': { + name: 'ENG TORQUE:index', + units: 'Foot pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) vibration. */ + 'ENG_VIBRATION:index': { + name: 'ENG VIBRATION:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Estimated fuel flow to the indexed engine (see note) at cruise speed. */ + 'ESTIMATED_FUEL_FLOW:index': { + name: 'ESTIMATED FUEL FLOW:index', + units: 'Pounds per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Full throttle thrust to weight ratio */ + FULL_THROTTLE_THRUST_TO_WEIGHT_RATIO: { + name: 'FULL THROTTLE THRUST TO WEIGHT RATIO', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) anti-ice switch state - 0 (FALSE) is off and 1 (TRUE) is on. */ + 'GENERAL_ENG_ANTI_ICE_POSITION:index': { + name: 'GENERAL ENG ANTI ICE POSITION:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Set the indexed engine (see note) combustion flag to TRUE or FALSE. Note that this will not only stop all combustion, but it will also set the engine RPM to 0, regardless of the actual state of the simulation. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'GENERAL_ENG_COMBUSTION:index': { + name: 'GENERAL ENG COMBUSTION:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This SimVar is similar to GENERAL ENG COMBUSTION, in that it can also be used to enable or disable engine combustion. However this SimVar will not interfere with the current state of ths simulation. For example, if the aircraft has a turbine engine with auto_ignition enabled or it's a propeller engine with magnetos, then in the subsequent simulation frames this SimVar may be set to 1 (TRUE) again as the engine restarts automatically. */ + 'GENERAL_ENG_COMBUSTION_EX1:index': { + name: 'GENERAL ENG COMBUSTION EX1:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Percent of maximum sound being created by the indexed engine (see note). + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'GENERAL_ENG_COMBUSTION_SOUND_PERCENT:index': { + name: 'GENERAL ENG COMBUSTION SOUND PERCENT:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of total damage to the indexed engine (see note). */ + 'GENERAL_ENG_DAMAGE_PERCENT:index': { + name: 'GENERAL ENG DAMAGE PERCENT:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Total elapsed time since the indexed engine (see note) was started. */ + 'GENERAL_ENG_ELAPSED_TIME:index': { + name: 'GENERAL ENG ELAPSED TIME:index', + units: 'Hours', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) exhaust gas temperature. */ + 'GENERAL_ENG_EXHAUST_GAS_TEMPERATURE:index': { + name: 'GENERAL ENG EXHAUST GAS TEMPERATURE:index', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed engine (see note) fail flag. */ + 'GENERAL_ENG_FAILED:index': { + name: 'GENERAL ENG FAILED:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Detects if a fire has been detected in an indexed engine (see note) or not. If 0 (FALSE) no fire has been detected and if 1 (TRUE) then it has. */ + 'GENERAL_ENG_FIRE_DETECTED:index': { + name: 'GENERAL ENG FIRE DETECTED:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The indexed engine (see note) fuel pressure. */ + 'GENERAL_ENG_FUEL_PRESSURE:index': { + name: 'GENERAL ENG FUEL PRESSURE:index', + units: 'Pounds per square inch (psi', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Whether the indexed engine (see note) fuel pump on (1, TRUE) or off (0, FALSE). */ + 'GENERAL_ENG_FUEL_PUMP_ON:index': { + name: 'GENERAL ENG FUEL PUMP ON:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Fuel pump switch state the indexed engine (see note). If 0 (FALSE) the pump is off and if 1 (TRUE) then it is on. */ + 'GENERAL_ENG_FUEL_PUMP_SWITCH:index': { + name: 'GENERAL ENG FUEL PUMP SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Equivalent to GENERAL ENG FUEL PUMP SWITCH but differentiates between ON and AUTO */ + 'GENERAL_ENG_FUEL_PUMP_SWITCH_EX1:index': { + name: 'GENERAL ENG FUEL PUMP SWITCH EX1:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Fuel used since the indexed engine (see note) was last started. */ + 'GENERAL_ENG_FUEL_USED_SINCE_START:index': { + name: 'GENERAL ENG FUEL USED SINCE START:index', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Fuel valve state for the indexed engine (see note). If 0 (FALSE) then the valve is closed and if 1 (TRUE) then it is open. */ + 'GENERAL_ENG_FUEL_VALVE:index': { + name: 'GENERAL ENG FUEL VALVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Settable alternator (generator) on/off switch for the indexed engine (see note). */ + 'GENERAL_ENG_GENERATOR_ACTIVE:index': { + name: 'GENERAL ENG GENERATOR ACTIVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Alternator (generator) on/off switch state for the indexed engine (see note). */ + 'GENERAL_ENG_GENERATOR_SWITCH:index': { + name: 'GENERAL ENG GENERATOR SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This can be used to find the time since the indexed engine (see note) started running. Similar to ElapsedTachometerTime, this records the time the engine has been running, but instead of taking a % of the time based on the Pct/RPM this takes the full time, but only if a threshold RPM/speed is reached. You can set the thresholds using the accumulated_time_hobbs_min_pct_rpm + and accumulated_time_hobbs_min_knots parameters in the [GENERALENGINEDATA] section of the engines.cfg file. */ + 'GENERAL_ENG_HOBBS_ELAPSED_TIME:index': { + name: 'GENERAL ENG HOBBS ELAPSED TIME:index', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The alternator switch for a specific engine. Requires an engine index (1 - 4) when used. */ + GENERAL_ENG_MASTER_ALTERNATOR: { + name: 'GENERAL ENG MASTER ALTERNATOR', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Maximum attained rpm for the indexed engine (see note). */ + 'GENERAL_ENG_MAX_REACHED_RPM:index': { + name: 'GENERAL ENG MAX REACHED RPM:index', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of max mixture lever position for the indexed engine (see note). */ + 'GENERAL_ENG_MIXTURE_LEVER_POSITION:index': { + name: 'GENERAL ENG MIXTURE LEVER POSITION:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent of max oil capacity leaked for the indexed engine (see note). */ + 'GENERAL_ENG_OIL_LEAKED_PERCENT:index': { + name: 'GENERAL ENG OIL LEAKED PERCENT:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) oil pressure. */ + 'GENERAL_ENG_OIL_PRESSURE:index': { + name: 'GENERAL ENG OIL PRESSURE:index', + units: 'Psf', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed engine (see note) oil temperature. */ + 'GENERAL_ENG_OIL_TEMPERATURE:index': { + name: 'GENERAL ENG OIL TEMPERATURE:index', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent of max rated rpm for the indexed engine (see note). + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'GENERAL_ENG_PCT_MAX_RPM:index': { + name: 'GENERAL ENG PCT MAX RPM:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent of max prop lever position for the indexed engine (see note). */ + 'GENERAL_ENG_PROPELLER_LEVER_POSITION:index': { + name: 'GENERAL ENG PROPELLER LEVER POSITION:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This will return 1 (TRUE) if the reverse thruster is engaged, or 0 (FALSE) otherwise. */ + GENERAL_ENG_REVERSE_THRUST_ENGAGED: { + name: 'GENERAL ENG REVERSE THRUST ENGAGED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The RPM for an indexed engine (see note). + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'GENERAL_ENG_RPM:index': { + name: 'GENERAL ENG RPM:index', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed engine (see note) starter on/off state. */ + 'GENERAL_ENG_STARTER:index': { + name: 'GENERAL ENG STARTER:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the indexed engine (see note) starter is active. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'GENERAL_ENG_STARTER_ACTIVE:index': { + name: 'GENERAL ENG STARTER ACTIVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent of max throttle position for the indexed engine (see note). */ + 'GENERAL_ENG_THROTTLE_LEVER_POSITION:index': { + name: 'GENERAL ENG THROTTLE LEVER POSITION:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current mode of the managed throttle for the indexed engine (see note). */ + 'GENERAL_ENG_THROTTLE_MANAGED_MODE:index': { + name: 'GENERAL ENG THROTTLE MANAGED MODE:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Aircraft master ignition switch (grounds all engines magnetos). */ + MASTER_IGNITION_SWITCH: { + name: 'MASTER IGNITION SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The maximum EGT, as set using the egt_peak_temperature parameter in the engines.cfg file. */ + MAX_EGT: { + name: 'MAX EGT', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The maximum oil temperature, as set using the parameter oil_temp_heating_constant in the engines.cfg file. */ + MAX_OIL_TEMPERATURE: { + name: 'MAX OIL TEMPERATURE', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Maximum rated rpm for the indexed engine (see note). */ + MAX_RATED_ENGINE_RPM: { + name: 'MAX RATED ENGINE RPM', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Number of engines (minimum 0, maximum 4) */ + NUMBER_OF_ENGINES: { + name: 'NUMBER OF ENGINES', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, do not use! */ + OIL_AMOUNT: { + name: 'OIL AMOUNT', + units: 'FS7 Oil Quantity', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Auto-feather arming switch for the indexed engine (see note). Please see the Note On Autofeathering for more information. */ + 'PANEL_AUTO_FEATHER_SWITCH:index': { + name: 'PANEL AUTO FEATHER SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if prop auto cruise active */ + PROP_AUTO_CRUISE_ACTIVE: { + name: 'PROP AUTO CRUISE ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Auto-feather armed state for the indexed engine (see note). */ + 'PROP_AUTO_FEATHER_ARMED:index': { + name: 'PROP AUTO FEATHER ARMED:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The "prop beta" is the pitch of the blades of the propeller, and this can be used to retrieve the current pitch setting, per indexed engine (see note). */ + 'PROP_BETA:index': { + name: 'PROP BETA:index', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This can be used to enable the propeller forced beta mode (1, TRUE) or disable it (0, FALSE), when being written to. When being read from, it will return TRUE (1) if the forced beta mode is enabled or FALSE (0) if it isn't. When enabled, the PROP BETA FORCED POSITION value will be used to drive the prop beta, while the internal coded simulation logic is used when this is disabled. */ + PROP_BETA_FORCED_ACTIVE: { + name: 'PROP BETA FORCED ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Get or set the beta at which the prop is forced. Only valid when PROP BETA FORCED ACTIVE is TRUE (1). */ + PROP_BETA_FORCED_POSITION: { + name: 'PROP BETA FORCED POSITION', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The "prop beta" is the pitch of the blades of the propeller. This retrieves the maximum possible pitch value for all engines. */ + PROP_BETA_MAX: { + name: 'PROP BETA MAX', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The "prop beta" is the pitch of the blades of the propeller. This retrieves the minimum possible pitch value for all engines. */ + PROP_BETA_MIN: { + name: 'PROP BETA MIN', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The "prop beta" is the pitch of the blades of the propeller. This retrieves the minimum possible pitch value when the propeller is in reverse for all engines. */ + PROP_BETA_MIN_REVERSE: { + name: 'PROP BETA MIN REVERSE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if prop deice switch on for the indexed engine (see note). */ + 'PROP_DEICE_SWITCH:index': { + name: 'PROP DEICE SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This will return the feathered state of the propeller for an indexed engine (see note). The state is either feathered (true) or not (false). */ + 'PROP_FEATHERED:index': { + name: 'PROP FEATHERED:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Feathering inhibit flag for the indexed engine (see note). */ + 'PROP_FEATHERING_INHIBIT:index': { + name: 'PROP FEATHERING INHIBIT:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Prop feather switch for the indexed engine (see note). */ + 'PROP_FEATHER_SWITCH:index': { + name: 'PROP FEATHER SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent of max rated rpm for the indexed engine (see note). + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'PROP_MAX_RPM_PERCENT:index': { + name: 'PROP MAX RPM PERCENT:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Prop rotation angle. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + PROP_ROTATION_ANGLE: { + name: 'PROP ROTATION ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Propeller rpm for the indexed engine (see note). */ + 'PROP_RPM:index': { + name: 'PROP RPM:index', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if prop sync is active the indexed engine (see note). */ + 'PROP_SYNC_ACTIVE:index': { + name: 'PROP SYNC ACTIVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Corrected prop correction input on slaved engine for the indexed engine (see note). */ + 'PROP_SYNC_DELTA_LEVER:index': { + name: 'PROP SYNC DELTA LEVER:index', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Propeller thrust for the indexed engine (see note). + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'PROP_THRUST:index': { + name: 'PROP THRUST:index', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, do not use! */ + PROPELLER_ADVANCED_SELECTION: { + name: 'PROPELLER ADVANCED SELECTION', + units: 'Enum', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This checks if the shutoff valve to the engine has been pulled (true) or not (false). When pulled piston engines will be blocked from getting any fuel. */ + SHUTOFF_VALVE_PULLED: { + name: 'SHUTOFF VALVE PULLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent throttle defining lower limit (negative for reverse thrust equipped airplanes). */ + THROTTLE_LOWER_LIMIT: { + name: 'THROTTLE LOWER LIMIT', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Afterburner state for the indexed engine (see note). + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'TURB_ENG_AFTERBURNER:index': { + name: 'TURB ENG AFTERBURNER:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The percentage that the afterburner is running at. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'TURB_ENG_AFTERBURNER_PCT_ACTIVE:index': { + name: 'TURB ENG AFTERBURNER PCT ACTIVE:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The stage of the afterburner, or 0 if the afterburner is not active. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'TURB_ENG_AFTERBURNER_STAGE_ACTIVE:index': { + name: 'TURB ENG AFTERBURNER STAGE ACTIVE:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Bleed air pressure for the indexed engine (see note). */ + 'TURB_ENG_BLEED_AIR:index': { + name: 'TURB ENG BLEED AIR:index', + units: 'Pounds per square inch (psi', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Effective commanded N1 for the indexed turbine engine (see note). */ + 'TURB_ENG_COMMANDED_N1:index': { + name: 'TURB ENG COMMANDED N1:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** When the throttle is on idle position, this sets the condition levers to one of 3 positions to define the idle N1 target for the indexed engine (see note): + + Down position is the cut-off position that cuts the fuel to the engine, effectively shutting down the engine. + Middle position requires N1 to reach the low idle value when throttle is in idle position (low idle value can be checked using the TURB_ENG_LOW_IDLE SimVar). + High position requires N1 to reach the high idle value when throttle is in idle position (high idle value can be checked using the TURB_ENG_HIGH_IDLE SimVar). + + Note that this option requires several settings from the engines.cfg file to be set to specific values before working correctly: + + DisableMixtureControls needs to be set to 1 (TRUE). + tp_idle_range should be set to 0 (since there is no mixture setting). + idle_fuel_flow and idle_high_fuel_flow must be set to the same value (since there is no mixture setting to induce a variation between the 2). + low_idle_n1 and high_idle_n1 to be correctly set. */ + 'TURB_ENG_CONDITION_LEVER_POSITION:index': { + name: 'TURB ENG CONDITION LEVER POSITION:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Corrected fuel flow for the indexed engine (see note). */ + 'TURB_ENG_CORRECTED_FF:index': { + name: 'TURB ENG CORRECTED FF:index', + units: 'Pounds per hour', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed turbine engine (see note) corrected N1. */ + 'TURB_ENG_CORRECTED_N1:index': { + name: 'TURB ENG CORRECTED N1:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed turbine engine (see note) corrected N2. */ + 'TURB_ENG_CORRECTED_N2:index': { + name: 'TURB ENG CORRECTED N2:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The amount of free torque for the indexed turbine engine (see note). */ + 'TURB_ENG_FREE_TURBINE_TORQUE:index': { + name: 'TURB ENG FREE TURBINE TORQUE:index', + units: 'Foot Pound', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if fuel is available for the indexed engine (see note). */ + 'TURB_ENG_FUEL_AVAILABLE:index': { + name: 'TURB ENG FUEL AVAILABLE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is used to control the fuel efficiency loss of the indexed engine, from 0 - no fuel efficiency loss - to 100 - double the fuel consumption. */ + 'TURB_ENG_FUEL_EFFICIENCY_LOSS:index': { + name: 'TURB ENG FUEL EFFICIENCY LOSS:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed engine (see note) fuel flow rate. */ + 'TURB_ENG_FUEL_FLOW_PPH:index': { + name: 'TURB ENG FUEL FLOW PPH:index', + units: 'Pounds per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Retrieves the high idle N1 value to be reached by the the indexed turboprop engine (see note) with throttle in idle position and condition lever in high idle position (condition lever position can be checked or set using the TURB_ENG_CONDITION_LEVER_POSITION SimVar). */ + 'TURB_ENG_HIGH_IDLE:index': { + name: 'TURB ENG HIGH IDLE:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the the indexed turbine engine (see note) ignition switch is on. */ + 'TURB_ENG_IGNITION_SWITCH:index': { + name: 'TURB ENG IGNITION SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Position of the the indexed turbine engine (see note) Ignition Switch. Similar to TURB_ENG_IGNITION_SWITCH but differentiates between ON and AUTO. */ + 'TURB_ENG_IGNITION_SWITCH_EX1:index': { + name: 'TURB ENG IGNITION SWITCH EX1:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the ignition system is currently running for the indexed engine (see note). Depends on TURB_ENG_IGNITION_SWITCH_EX1 Enum, the cfg var ignition_auto_type and current state of the plane. */ + 'TURB_ENG_IS_IGNITING:index': { + name: 'TURB ENG IS IGNITING:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Retrieve or set the ITT for the indexed engine (see note). */ + 'TURB_ENG_ITT:index': { + name: 'TURB ENG ITT:index', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This is used to control the ITT cooling efficiency loss of the indexed engine, from 0 - no cooling efficiency loss - to 100 -engine recieves no ITT cooling. */ + 'TURB_ENG_ITT_COOLING_EFFICIENCY_LOSS:index': { + name: 'TURB ENG ITT COOLING EFFICIENCY LOSS:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed engine (see note) jet thrust. */ + 'TURB_ENG_JET_THRUST:index': { + name: 'TURB ENG JET THRUST:index', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Retrieves the low idle N1 value to be reached by the the indexed turboprop engine (see note) with throttle in idle position and condition lever in low idle position (condition lever position can be checked or set using the TURB_ENG_CONDITION_LEVER_POSITION SimVar). */ + 'TURB_ENG_LOW_IDLE:index': { + name: 'TURB ENG LOW IDLE:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the turbine engine master starter switch is on, false otherwise. */ + TURB_ENG_MASTER_STARTER_SWITCH: { + name: 'TURB ENG MASTER STARTER SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent of max rated torque for the indexed engine (see note). */ + 'TURB_ENG_MAX_TORQUE_PERCENT:index': { + name: 'TURB ENG MAX TORQUE PERCENT:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed turbine engine (see note) N1 value. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'TURB_ENG_N1:index': { + name: 'TURB ENG N1:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This is used to control the N1 loss of the indexed engine, from 0 - no N1 loss - to 100 - 100% N1 loss. */ + 'TURB_ENG_N1_LOSS:index': { + name: 'TURB ENG N1 LOSS:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed turbine engine (see note) N2 value. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'TURB_ENG_N2:index': { + name: 'TURB ENG N2:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Number of tanks currently being used by the indexed engine (see note). */ + 'TURB_ENG_NUM_TANKS_USED:index': { + name: 'TURB ENG NUM TANKS USED:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) pressure ratio. */ + 'TURB_ENG_PRESSURE_RATIO:index': { + name: 'TURB ENG PRESSURE RATIO:index', + units: 'Ratio', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent thrust of primary nozzle for the indexed engine (see note). */ + 'TURB_ENG_PRIMARY_NOZZLE_PERCENT:index': { + name: 'TURB ENG PRIMARY NOZZLE PERCENT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent thrust reverser nozzles deployed for the indexed engine (see note). + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'TURB_ENG_REVERSE_NOZZLE_PERCENT:index': { + name: 'TURB ENG REVERSE NOZZLE PERCENT:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Fuel tanks used by the indexed engine (see note), one or more of the following bit flags: + + Center 1 Bit 0 + Center 2 Bit 1 + Center 3 Bit 2 + Left Main Bit 3 + Left Aux Bit 4 + Left Tip Bit 5 + Right Main Bit 6 + Right Aux Bit 7 + Right Tip Bit 8 + External 1 Bit 9 + External 2 Bit 10 */ + 'TURB_ENG_TANKS_USED:index': { + name: 'TURB ENG TANKS USED:index', + units: 'Mask', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Fuel tank selected for the indexed engine (see note). See Fuel Tank Selection for a list of values. */ + 'TURB_ENG_TANK_SELECTOR:index': { + name: 'TURB ENG TANK SELECTOR:index', + units: 'Enum', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The indexed turbine engine (see note) commanded N1 for current throttle position. */ + 'TURB_ENG_THROTTLE_COMMANDED_N1:index': { + name: 'TURB ENG THROTTLE COMMANDED N1:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This can be used to control the thrust efficiency loss of the indexed engine, where a value of 0 is 100% of available thrust, and 100 is 0% available thrust. */ + 'TURB_ENG_THRUST_EFFICIENCY_LOSS:index': { + name: 'TURB ENG THRUST EFFICIENCY LOSS:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed turbine engine (see note) vibration value. */ + 'TURB_ENG_VIBRATION:index': { + name: 'TURB ENG VIBRATION:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Retrieve the itt_peak_temperature as set in the engines.cfg file. */ + TURB_MAX_ITT: { + name: 'TURB MAX ITT', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Carburetor temperature the indexed engine (see note). */ + 'RECIP_CARBURETOR_TEMPERATURE:index': { + name: 'RECIP CARBURETOR TEMPERATURE:index', + units: 'Celsius', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Alternate air control the indexed engine (see note). */ + 'RECIP_ENG_ALTERNATE_AIR_POSITION:index': { + name: 'RECIP ENG ALTERNATE AIR POSITION:index', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The maximum quantity of water/methanol mixture in the ADI tank for the indexed engine (see note). This value is set as part of the [ANTIDETONATION_SYSTEM.N] section in the aircraft configuration files. */ + 'RECIP_ENG_ANTIDETONATION_TANK_MAX_QUANTITY:index': { + name: 'RECIP ENG ANTIDETONATION TANK MAX QUANTITY:index', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The quantity of water/methanol mixture currently in the ADI tank for the indexed engine (see note). */ + 'RECIP_ENG_ANTIDETONATION_TANK_QUANTITY:index': { + name: 'RECIP ENG ANTIDETONATION TANK QUANTITY:index', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The status of the ADI tank valve for the indexed engine (see note). */ + 'RECIP_ENG_ANTIDETONATION_TANK_VALVE:index': { + name: 'RECIP ENG ANTIDETONATION TANK VALVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This gives the actual flow rate of the Anti Detonation system for the indexed engine (see note). */ + 'RECIP_ENG_ANTIDETONATION_FLOW_RATE:index': { + name: 'RECIP ENG ANTIDETONATION FLOW RATE:index', + units: 'Gallons per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Brake power produced by the indexed engine (see note). */ + 'RECIP_ENG_BRAKE_POWER:index': { + name: 'RECIP ENG BRAKE POWER:index', + units: 'Foot pounds (ftlbs) per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent coolant available for the indexed engine (see note). */ + 'RECIP_ENG_COOLANT_RESERVOIR_PERCENT:index': { + name: 'RECIP ENG COOLANT RESERVOIR PERCENT:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent cowl flap opened for the indexed engine (see note). */ + 'RECIP_ENG_COWL_FLAP_POSITION:index': { + name: 'RECIP ENG COWL FLAP POSITION:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Engine cylinder head temperature for the indexed engine (see note). */ + 'RECIP_ENG_CYLINDER_HEAD_TEMPERATURE:index': { + name: 'RECIP ENG CYLINDER HEAD TEMPERATURE:index', + units: 'Celsius', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Index high 16 bits is engine number, low16 cylinder number, both indexed from 1. */ + 'RECIP_ENG_CYLINDER_HEALTH:index': { + name: 'RECIP ENG CYLINDER HEALTH:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Set to 1 (TRUE) if the indexed engine (see note) is detonating. */ + 'RECIP_ENG_DETONATING:index': { + name: 'RECIP ENG DETONATING:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether emergency boost is active (1, TRUE) or not (0, FALSE) for the indexed engine (see note). */ + 'RECIP_ENG_EMERGENCY_BOOST_ACTIVE:index': { + name: 'RECIP ENG EMERGENCY BOOST ACTIVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The elapsed time that emergency boost has been active on the indexed engine (see note). The timer will start when boost is first activated. + IMPORTANT! This timer does not reset. So if you set your time limit in the engines.cfg file to 315s and you spend 2 minutes with boost active, then pull back on the throttle for 1 minute, then engage boost again for 2 minutes, the simulation will consider that you spent 4 minutes with boost active. The 1 minute pause is not taken into account. */ + 'RECIP_ENG_EMERGENCY_BOOST_ELAPSED_TIME:index': { + name: 'RECIP ENG EMERGENCY BOOST ELAPSED TIME:index', + units: 'Hours', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Whether or not the Engine Master switch is active on an indexed engine (see note). */ + 'RECIP_ENG_ENGINE_MASTER_SWITCH:index': { + name: 'RECIP ENG ENGINE MASTER SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if fuel is available for the indexed engine (see note). */ + 'RECIP_ENG_FUEL_AVAILABLE:index': { + name: 'RECIP ENG FUEL AVAILABLE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The indexed engine (see note) fuel flow. */ + 'RECIP_ENG_FUEL_FLOW:index': { + name: 'RECIP ENG FUEL FLOW:index', + units: 'Pounds per hour', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Number of tanks currently being used by the indexed engine (see note). */ + 'RECIP_ENG_FUEL_NUMBER_TANKS_USED:index': { + name: 'RECIP ENG FUEL NUMBER TANKS USED:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Fuel tanks used by the indexed engine (see note), one or more of the following bit flags: + + Center 1 Bit 0 + Center 2 Bit 1 + Center 3 Bit 2 + Left Main Bit 3 + Left Aux Bit 4 + Left Tip Bit 5 + Right Main Bit 6 + Right Aux Bit 7 + Right Tip Bit 8 + External 1 Bit 9 + External 2 Bit 10 */ + 'RECIP_ENG_FUEL_TANKS_USED:index': { + name: 'RECIP ENG FUEL TANKS USED:index', + units: 'Mask', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Fuel tank selected for the indexed engine (see note). See Fuel Tank Selection for a list of values. */ + 'RECIP_ENG_FUEL_TANK_SELECTOR:index': { + name: 'RECIP ENG FUEL TANK SELECTOR:index', + units: 'Enum', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the Glow Plug is active on the indexed engine (see note).. */ + 'RECIP_ENG_GLOW_PLUG_ACTIVE:index': { + name: 'RECIP ENG GLOW PLUG ACTIVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Left magneto state for the indexed engine (see note). */ + 'RECIP_ENG_LEFT_MAGNETO:index': { + name: 'RECIP ENG LEFT MAGNETO:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The indexed engine (see note) manifold pressure. */ + 'RECIP_ENG_MANIFOLD_PRESSURE:index': { + name: 'RECIP ENG MANIFOLD PRESSURE:index', + units: 'Pounds per square inch (psi', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The maximum quantity of nitrous permitted per indexed engine (see note). */ + 'RECIP_ENG_NITROUS_TANK_MAX_QUANTITY:index': { + name: 'RECIP ENG NITROUS TANK MAX QUANTITY:index', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The quantity of nitrous per indexed engine (see note). */ + 'RECIP_ENG_NITROUS_TANK_QUANTITY:index': { + name: 'RECIP ENG NITROUS TANK QUANTITY:index', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The statte of the nitrous tank valve for the indexed engine (see note). Either 1 (TRUE) for open or 0 (FALSE) for closed. */ + RECIP_ENG_NITROUS_TANK_VALVE: { + name: 'RECIP ENG NITROUS TANK VALVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The number of cylinders for the indexed engine (see note). */ + 'RECIP_ENG_NUM_CYLINDERS:index': { + name: 'RECIP ENG NUM CYLINDERS:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The number of cylinders that have failed in the indexed engine (see note). */ + 'RECIP_ENG_NUM_CYLINDERS_FAILED:index': { + name: 'RECIP ENG NUM CYLINDERS FAILED:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) primer state. */ + 'RECIP_ENG_PRIMER:index': { + name: 'RECIP ENG PRIMER:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The indexed engine (see note) radiator temperature. */ + 'RECIP_ENG_RADIATOR_TEMPERATURE:index': { + name: 'RECIP ENG RADIATOR TEMPERATURE:index', + units: 'Celsius', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed engine (see note) right magneto state. */ + 'RECIP_ENG_RIGHT_MAGNETO:index': { + name: 'RECIP ENG RIGHT MAGNETO:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Torque produced by the indexed engine (see note). */ + 'RECIP_ENG_STARTER_TORQUE:index': { + name: 'RECIP ENG STARTER TORQUE:index', + units: 'Foot pound', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns which of the supercharger gears is engaged for the indexed engine (see note). */ + 'RECIP_ENG_SUPERCHARGER_ACTIVE_GEAR:index': { + name: 'RECIP ENG SUPERCHARGER ACTIVE GEAR:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed engine (see note) turbine inlet temperature. */ + 'RECIP_ENG_TURBINE_INLET_TEMPERATURE:index': { + name: 'RECIP ENG TURBINE INLET TEMPERATURE:index', + units: 'Celsius', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The indexed engine (see note) turbo failed state. */ + 'RECIP_ENG_TURBOCHARGER_FAILED:index': { + name: 'RECIP ENG TURBOCHARGER FAILED:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** When the engines.cfg parameter turbocharged is TRUE, this SimVar will return the percentage that the turbo waste gate is closed for the indexed engine (see note). If the turbocharged variable is FALSE and the manifold_pressure_regulator parameter is TRUE, then this will return the percentage that the manifold pressure regulator is closed for the indexed engine. */ + 'RECIP_ENG_WASTEGATE_POSITION:index': { + name: 'RECIP ENG WASTEGATE POSITION:index', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This will return the cylinder head temperature value set by the cht_heating_constant parameter in the engines.cfg file. */ + RECIP_MAX_CHT: { + name: 'RECIP MAX CHT', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Fuel / Air mixture ratio for the indexed engine (see note). */ + 'RECIP_MIXTURE_RATIO:index': { + name: 'RECIP MIXTURE RATIO:index', + units: 'Ratio', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Beta dot */ + BETA_DOT: { + name: 'BETA DOT', + units: 'Radians per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Design decision altitude above mean sea level */ + DECISION_ALTITUDE_MSL: { + name: 'DECISION ALTITUDE MSL', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Design decision height */ + DECISION_HEIGHT: { + name: 'DECISION HEIGHT', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This design constant represents the optimal altitude the aircraft should maintain when in cruise. It is derived from the cruise_alt setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default is 1500ft. */ + DESIGN_CRUISE_ALT: { + name: 'DESIGN CRUISE ALT', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This design constant represents the spawn altitude for the aircraft when spawning in cruise. It is derived from the spawn_cruise_altitude setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default is 1500ft. */ + DESIGN_SPAWN_ALTITUDE_CRUISE: { + name: 'DESIGN SPAWN ALTITUDE CRUISE', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This design constant represents the spawn altitude for the aircraft when spawning in descent. It is derived from the spawn_descent_altitude setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default is 500ft. */ + DESIGN_SPAWN_ALTITUDE_DESCENT: { + name: 'DESIGN SPAWN ALTITUDE DESCENT', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This design constant represents the optimal climb speed for the aircraft. It is derived from the climb_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is -1. */ + DESIGN_SPEED_CLIMB: { + name: 'DESIGN SPEED CLIMB', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This design constant represents the minimum speed required for aircraft rotation. It is derived from the rotation_speed_min setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is -1. */ + DESIGN_SPEED_MIN_ROTATION: { + name: 'DESIGN SPEED MIN ROTATION', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This design constant represents the aircraft ideal cruising speed. It is derived from the cruise_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. The default value is computed an internal function that uses the estimated cruise altitude and estimated cruise percent power, according of the engine type, the number of engines, the density, the wing area and some drag parameters. Normally this value is set in the CFG file and the default value is never used. */ + DESIGN_SPEED_VC: { + name: 'DESIGN SPEED VC', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This design constant represents the the stall speed when flaps are fully extended. It is derived from the full_flaps_stall_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is 0.8 x VS. */ + DESIGN_SPEED_VS0: { + name: 'DESIGN SPEED VS0', + units: 'kias', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This design constant represents the stall speed when flaps are fully retracted. It is derived from the flaps_up_stall_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is 0. */ + DESIGN_SPEED_VS1: { + name: 'DESIGN SPEED VS1', + units: 'kias', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This design constant represents the aircraft ideal takoff speed. It is derived from the takeoff_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. */ + DESIGN_TAKEOFF_SPEED: { + name: 'DESIGN TAKEOFF SPEED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Dynamic pressure */ + DYNAMIC_PRESSURE: { + name: 'DYNAMIC PRESSURE', + units: 'Pounds per square foot (psf)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Estimated cruise speed */ + ESTIMATED_CRUISE_SPEED: { + name: 'ESTIMATED CRUISE SPEED', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Current g force */ + G_FORCE: { + name: 'G FORCE', + units: 'GForce', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This returns the setting of the G-limiter, as set using the GLimiterSetting parameter. */ + G_LIMITER_SETTING: { + name: 'G LIMITER SETTING', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Angle of attack */ + INCIDENCE_ALPHA: { + name: 'INCIDENCE ALPHA', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Sideslip angle */ + INCIDENCE_BETA: { + name: 'INCIDENCE BETA', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the aircraft is a taildragger */ + IS_TAIL_DRAGGER: { + name: 'IS TAIL DRAGGER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Linear CL alpha */ + LINEAR_CL_ALPHA: { + name: 'LINEAR CL ALPHA', + units: 'Per radian', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Maximum design mach */ + MACH_MAX_OPERATE: { + name: 'MACH MAX OPERATE', + units: 'Mach', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Maximum G force attained */ + MAX_G_FORCE: { + name: 'MAX G FORCE', + units: 'Gforce', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Minimum drag velocity, +in clean, with no input and no gears, when at 10000ft. */ + MIN_DRAG_VELOCITY: { + name: 'MIN DRAG VELOCITY', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Minimum G force attained */ + MIN_G_FORCE: { + name: 'MIN G FORCE', + units: 'Gforce', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, do not use! */ + SEMIBODY_LOADFACTOR_X: { + name: 'SEMIBODY LOADFACTOR X', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Acceleration along the axis Y divided by the gravity constant g (usually around 9.81m.s²) */ + SEMIBODY_LOADFACTOR_Y: { + name: 'SEMIBODY LOADFACTOR Y', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Derivative of SEMIBODY LOADFACTOR Y in relation to time. */ + SEMIBODY_LOADFACTOR_YDOT: { + name: 'SEMIBODY LOADFACTOR YDOT', + units: 'Per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, do not use! */ + SEMIBODY_LOADFACTOR_Z: { + name: 'SEMIBODY LOADFACTOR Z', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Sigma sqrt */ + SIGMA_SQRT: { + name: 'SIGMA SQRT', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Simulated radius */ + SIMULATED_RADIUS: { + name: 'SIMULATED RADIUS', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The angle of attack which produces the maximum lift coefficient before entering into stall conditions. */ + STALL_ALPHA: { + name: 'STALL ALPHA', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The angle at which static pitch stability is achieved. */ + STATIC_PITCH: { + name: 'STATIC PITCH', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** the typical (normal) descent rate for the aircraft. */ + TYPICAL_DESCENT_RATE: { + name: 'TYPICAL DESCENT RATE', + units: 'Feet (ft) per minute', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Total wing area */ + WING_AREA: { + name: 'WING AREA', + units: 'Square feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current wing flex. Different values can be set for each wing (for example, during banking). Set an index of 1 for the left wing, and 2 for the right wing. */ + 'WING_FLEX_PCT:index': { + name: 'WING FLEX PCT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Total wing span */ + WING_SPAN: { + name: 'WING SPAN', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The yaw string angle. Yaw strings are attached to gliders as visible indicators of the yaw angle. An animation of this is not implemented in ESP. */ + YAW_STRING_ANGLE: { + name: 'YAW STRING ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Yaw string angle as a percentage */ + YAW_STRING_PCT_EXTENDED: { + name: 'YAW STRING PCT EXTENDED', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The angle of attack at which the wing has zero lift. */ + ZERO_LIFT_ALPHA: { + name: 'ZERO LIFT ALPHA', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Most backward authorized position of the CG according to the POH. + NOTE: This is only valid for airplanes. */ + CG_AFT_LIMIT: { + name: 'CG AFT LIMIT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The longitudinal CG position relative to the Reference Datum Position. + NOTE: This is only valid for helicopters. */ + CG_FEET: { + name: 'CG FEET', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The aft +CG +limit position relative to the Reference Datum Position. + NOTE: This is only valid for helicopters. */ + CG_FEET_AFT_LIMIT: { + name: 'CG FEET AFT LIMIT', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The lateral +CG position relative to the Reference Datum Position. + NOTE: This is only valid for helicopters. */ + CG_FEET_LATERAL: { + name: 'CG FEET LATERAL', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The left hand lateral +CG position relative to the Reference Datum Position. + NOTE: This is only valid for helicopters. */ + CG_FEET_LATERAL_LEFT_LIMIT: { + name: 'CG FEET LATERAL LEFT LIMIT', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The right hand lateral +CG position relative to the Reference Datum Position. + NOTE: This is only valid for helicopters. */ + CG_FEET_LATERAL_RIGHT_LIMIT: { + name: 'CG FEET LATERAL RIGHT LIMIT', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The forward +CG +limit position relative to the Reference Datum Position. + NOTE: This is only valid for helicopters. */ + CG_FEET_FWD_LIMIT: { + name: 'CG FEET FWD LIMIT', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Most forward authorized position of the CG according to the POH. + NOTE: This is only valid for airplanes. */ + CG_FWD_LIMIT: { + name: 'CG FWD LIMIT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, do not use! */ + CG_MAX_MACH: { + name: 'CG MAX MACH', + units: 'Mach', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, do not use! */ + CG_MIN_MACH: { + name: 'CG MIN MACH', + units: 'Mach', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Longitudinal CG position as a percent of reference Chord. + NOTE: This is only valid for airplanes. */ + CG_PERCENT: { + name: 'CG PERCENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Lateral CG position as a percent of reference Chord. + NOTE: This is only valid for airplanes. */ + CG_PERCENT_LATERAL: { + name: 'CG PERCENT LATERAL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Static CG position with reference to the ground. + NOTE: This is only valid for airplanes. */ + STATIC_CG_TO_GROUND: { + name: 'STATIC CG TO GROUND', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point orientation: Bank */ + INTERACTIVE_POINT_BANK: { + name: 'INTERACTIVE POINT BANK', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point orientation: Heading */ + INTERACTIVE_POINT_HEADING: { + name: 'INTERACTIVE POINT HEADING', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point Jetway constant, determining the desired left bend ratio of jetway hood */ + INTERACTIVE_POINT_JETWAY_LEFT_BEND: { + name: 'INTERACTIVE POINT JETWAY LEFT BEND', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point Jetway constant, determining the desired left deployment angle of jetway hood */ + INTERACTIVE_POINT_JETWAY_LEFT_DEPLOYMENT: { + name: 'INTERACTIVE POINT JETWAY LEFT DEPLOYMENT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point Jetway constant, determining the desired right bend ratio of jetway hood */ + INTERACTIVE_POINT_JETWAY_RIGHT_BEND: { + name: 'INTERACTIVE POINT JETWAY RIGHT BEND', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point Jetway constant, determining the desired right deployment angle of jetway hood */ + INTERACTIVE_POINT_JETWAY_RIGHT_DEPLOYMENT: { + name: 'INTERACTIVE POINT JETWAY RIGHT DEPLOYMENT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point Jetway constant, determining the desired top horizontal ratio of displacement of jetway hood */ + INTERACTIVE_POINT_JETWAY_TOP_HORIZONTAL: { + name: 'INTERACTIVE POINT JETWAY TOP HORIZONTAL', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point Jetway constant, determining the desired top vertical ratio of displacement of jetway hood */ + INTERACTIVE_POINT_JETWAY_TOP_VERTICAL: { + name: 'INTERACTIVE POINT JETWAY TOP VERTICAL', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The Interactive Point goal percentage of opening (if it's for a door) or percentage of deployment (if it's for a hose or cable). */ + INTERACTIVE_POINT_GOAL: { + name: 'INTERACTIVE POINT GOAL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Interactive Point current percentage of opening (if door) or deployment (if hose/cable) */ + INTERACTIVE_POINT_OPEN: { + name: 'INTERACTIVE POINT OPEN', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Interactive Point orientation: Pitch */ + INTERACTIVE_POINT_PITCH: { + name: 'INTERACTIVE POINT PITCH', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point X position relative to datum reference point */ + INTERACTIVE_POINT_POSX: { + name: 'INTERACTIVE POINT POSX', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point Y position relative to datum reference point */ + INTERACTIVE_POINT_POSY: { + name: 'INTERACTIVE POINT POSY', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Interactive Point Z position relative to datum reference point */ + INTERACTIVE_POINT_POSZ: { + name: 'INTERACTIVE POINT POSZ', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The type of interactive point */ + INTERACTIVE_POINT_TYPE: { + name: 'INTERACTIVE POINT TYPE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Empty weight of the aircraft */ + EMPTY_WEIGHT: { + name: 'EMPTY WEIGHT', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Empty weight cross coupled moment of inertia */ + EMPTY_WEIGHT_CROSS_COUPLED_MOI: { + name: 'EMPTY WEIGHT CROSS COUPLED MOI', + units: 'Slugs per feet squared (Slug sqft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Empty weight pitch moment of inertia */ + EMPTY_WEIGHT_PITCH_MOI: { + name: 'EMPTY WEIGHT PITCH MOI', + units: 'Slugs per feet squared (Slug sqft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Empty weight roll moment of inertia */ + EMPTY_WEIGHT_ROLL_MOI: { + name: 'EMPTY WEIGHT ROLL MOI', + units: 'Slugs per feet squared (Slug sqft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Empty weight yaw moment of inertia */ + EMPTY_WEIGHT_YAW_MOI: { + name: 'EMPTY WEIGHT YAW MOI', + units: 'Slugs per feet squared (Slug sqft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Maximum gross weight of the aircaft */ + MAX_GROSS_WEIGHT: { + name: 'MAX GROSS WEIGHT', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Total weight of the aircraft */ + TOTAL_WEIGHT: { + name: 'TOTAL WEIGHT', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Total weight cross coupled moment of inertia */ + TOTAL_WEIGHT_CROSS_COUPLED_MOI: { + name: 'TOTAL WEIGHT CROSS COUPLED MOI', + units: 'Slugs per feet squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Total weight pitch moment of inertia */ + TOTAL_WEIGHT_PITCH_MOI: { + name: 'TOTAL WEIGHT PITCH MOI', + units: 'Slugs per feet squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Total weight roll moment of inertia */ + TOTAL_WEIGHT_ROLL_MOI: { + name: 'TOTAL WEIGHT ROLL MOI', + units: 'Slugs per feet squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Total weight yaw moment of inertia */ + TOTAL_WEIGHT_YAW_MOI: { + name: 'TOTAL WEIGHT YAW MOI', + units: 'Slugs per feet squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Cross feed valve setting. This will return the current setting for the fuel crossfeed for the indexed engine, based on the current status of the simulation and the Cross Feed key events. */ + 'FUEL_CROSS_FEED:index': { + name: 'FUEL CROSS FEED:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** If 1 (TRUE) then the aircraft can dump fuel. */ + FUEL_DUMP_ACTIVE: { + name: 'FUEL DUMP ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** If set to 1 (TRUE) then the aircraft will dump fuel at the rate set by fuel_dump_rate parameter in the flight_model.cfg +file. */ + FUEL_DUMP_SWITCH: { + name: 'FUEL DUMP SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Maximum capacity in volume of all the tanks on the left side of the aircraft. */ + FUEL_LEFT_CAPACITY: { + name: 'FUEL LEFT CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Current quantity in volume of all the tanks on the left side of the aircraft. */ + FUEL_LEFT_QUANTITY: { + name: 'FUEL LEFT QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Currently not used within the simulation. */ + FUEL_PUMP: { + name: 'FUEL PUMP', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Maximum capacity in volume of all the tanks on the right side of the aircraft. */ + FUEL_RIGHT_CAPACITY: { + name: 'FUEL RIGHT CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Current quantity in volume of all the tanks on the right side of the aircraft. */ + FUEL_RIGHT_QUANTITY: { + name: 'FUEL RIGHT QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Quantity of fuel in the tank referenced by the indexed selector. +When using the legacy fuel system, this SimVar will return the quantity of fuel in the tank pointed to by the selector you chose with the index. If passing an index higher than the number of selectors - or when using the modern fuel system - it will return the total fuel quantity available. */ + 'FUEL_SELECTED_QUANTITY:index': { + name: 'FUEL SELECTED QUANTITY:index', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent or capacity for the tank referenced by the indexed selector. +When using the legacy fuel system, this SimVar will return the percentage of fuel in the tank pointed to by the selector you chose with the index. If passing an index higher than the number of selectors available - or when using the modern fuel system - it will return the percentage of total fuel quantity available. */ + 'FUEL_SELECTED_QUANTITY_PERCENT:index': { + name: 'FUEL SELECTED QUANTITY PERCENT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The method of transfer for the fuel. Each of the available transfer options are explained below: + + off - Fuel transfer is switched off. + auto - Automatically balance the fuel between the Center1 and Center2 tanks to maintain the center of gravity. + forward - Fuel will be transferred forwards from the Center1 tank to the Center2 tank. + aft - Fuel will be transferred aftwards from the Center2 tank to the Center1 tank. + manual - Fuel will be transferred for 1 second from the Center1 tank to the Center2 tank at a rate of 1lbs/s. + custom - This requires one or more pumps to have been defined using the fuel_transfer_pump.N parameter in the flight_model.cfg file, as well as their associated electrical circuits. */ + FUEL_SELECTED_TRANSFER_MODE: { + name: 'FUEL SELECTED TRANSFER MODE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Total fuel capacity of the aircraft for all tanks. */ + FUEL_TOTAL_CAPACITY: { + name: 'FUEL TOTAL CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Current total quantity of fuel in volume for all tanks of the aircraft. */ + FUEL_TOTAL_QUANTITY: { + name: 'FUEL TOTAL QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Current total fuel weight for all tanks of the aircraft */ + FUEL_TOTAL_QUANTITY_WEIGHT: { + name: 'FUEL TOTAL QUANTITY WEIGHT', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns 1 (TRUE) if the indexed pump is active. */ + 'FUEL_TRANSFER_PUMP_ON:index': { + name: 'FUEL TRANSFER PUMP ON:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The weight of the fuel, per gallon. */ + FUEL_WEIGHT_PER_GALLON: { + name: 'FUEL WEIGHT PER GALLON', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Will return 1 (TRUE) if the aircraft is using the modern [FUEL_SYSTEM] or 0 (FALSE) for the legacy [FUEL]. */ + NEW_FUEL_SYSTEM: { + name: 'NEW FUEL SYSTEM', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The number of fuel selectors on the aircraft. */ + NUM_FUEL_SELECTORS: { + name: 'NUM FUEL SELECTORS', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Will return 1 (TRUE) if the unlimited fuel flag has been enabled, or 0 (FALSE) otherwise. */ + UNLIMITED_FUEL: { + name: 'UNLIMITED FUEL', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The total amount of fuel in all tanks of the aircraft which is not usable. */ + UNUSABLE_FUEL_TOTAL_QUANTITY: { + name: 'UNUSABLE FUEL TOTAL QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The pressure of the fuel coming to the indexed engine. The index is the number of the engine N component as defined by the Engine.N parameter. */ + 'FUELSYSTEM_ENGINE_PRESSURE:index': { + name: 'FUELSYSTEM ENGINE PRESSURE:index', + units: 'Kilo pascal', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This will return the current Option for the indexed junction. The index is the number of the line N component as defined by the Junction.N parameter. */ + 'FUELSYSTEM_JUNCTION_SETTING:index': { + name: 'FUELSYSTEM JUNCTION SETTING:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The fuel flowing through the indexed line in Gallons per Hour. The index is the number of the line N component as defined by the Line.N parameter. */ + 'FUELSYSTEM_LINE_FUEL_FLOW:index': { + name: 'FUELSYSTEM LINE FUEL FLOW:index', + units: 'Gallons per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The level of fuel in the indexed line in Gallons. The index is the number of the line N component as defined by the Line.N parameter. */ + 'FUELSYSTEM_LINE_FUEL_LEVEL:index': { + name: 'FUELSYSTEM LINE FUEL LEVEL:index', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The pressure in the indexed fuel line, measured in KiloPascal. The index is the number of the line N component as defined by the Line.N parameter. */ + 'FUELSYSTEM_LINE_FUEL_PRESSURE:index': { + name: 'FUELSYSTEM LINE FUEL PRESSURE:index', + units: 'Kilo pascal', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether or not the indexed pump is actually active. The index is the number of the pump N component as defined by the Pump.N parameter. */ + 'FUELSYSTEM_PUMP_ACTIVE:index': { + name: 'FUELSYSTEM PUMP ACTIVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the indexed pump is enabled. The index is the number of the pump N component as defined by the Pump.N parameter. */ + 'FUELSYSTEM_PUMP_SWITCH:index': { + name: 'FUELSYSTEM PUMP SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Total capacity of the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter. + NOTE: This SimVar can only be used with the modern Fuel System. */ + 'FUELSYSTEM_TANK_CAPACITY:index': { + name: 'FUELSYSTEM TANK CAPACITY:index', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Quantity of fuel available in the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter. + NOTE: This SimVar can only be used with the modern Fuel System. */ + 'FUELSYSTEM_TANK_LEVEL:index': { + name: 'FUELSYSTEM TANK LEVEL:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Quantity of fuel currently available in the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter. + NOTE: If the fuel system +Version +is 2 or below, the index value will be one of the +Fuel Tank Selection +indices. */ + 'FUELSYSTEM_TANK_QUANTITY:index': { + name: 'FUELSYSTEM TANK QUANTITY:index', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Total quantity of fuel available in the indexed fuel tank, including any unusable fuel. The index is the number of the tank N component as defined by the Tank.N parameter. + NOTE: If the fuel system +Version +is 2 or below, the index value will be one of the +Fuel Tank Selection +indices. */ + 'FUELSYSTEM_TANK_TOTAL_QUANTITY:index': { + name: 'FUELSYSTEM TANK TOTAL QUANTITY:index', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Weight of fuel available in the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter. + NOTE: If the fuel system +Version +is 2 or below, the index value will be one of the +Fuel Tank Selection +indices. */ + 'FUELSYSTEM_TANK_WEIGHT:index': { + name: 'FUELSYSTEM TANK WEIGHT:index', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Whether or not the indexed trigger is active. The index is the number of the trigger N component as defined by the Trigger.N parameter. */ + 'FUELSYSTEM_TRIGGER_STATUS:index': { + name: 'FUELSYSTEM TRIGGER STATUS:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the indexed valve is actually fully opened. The index is the number of the valve N component as defined by the Valve.N parameter. */ + 'FUELSYSTEM_VALVE_OPEN:index': { + name: 'FUELSYSTEM VALVE OPEN:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether or not the indexed valve is set to be opened. The index is the number of the valve N component as defined by the Valve.N parameter. */ + 'FUELSYSTEM_VALVE_SWITCH:index': { + name: 'FUELSYSTEM VALVE SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Maximum capacity in volume of +center tank 1/2/3. */ + FUEL_TANK_CENTER_CAPACITY: { + name: 'FUEL TANK CENTER CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Maximum capacity in volume of +center tank 1/2/3. */ + FUEL_TANK_CENTER2_CAPACITY: { + name: 'FUEL TANK CENTER2 CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Maximum capacity in volume of +center tank 1/2/3. */ + FUEL_TANK_CENTER3_CAPACITY: { + name: 'FUEL TANK CENTER3 CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of maximum capacity of center tank 1/2/3. */ + FUEL_TANK_CENTER_LEVEL: { + name: 'FUEL TANK CENTER LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent of maximum capacity of center tank 1/2/3. */ + FUEL_TANK_CENTER2_LEVEL: { + name: 'FUEL TANK CENTER2 LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent of maximum capacity of center tank 1/2/3. */ + FUEL_TANK_CENTER3_LEVEL: { + name: 'FUEL TANK CENTER3 LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of center tank 1/2/3. */ + FUEL_TANK_CENTER_QUANTITY: { + name: 'FUEL TANK CENTER QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of center tank 1/2/3. */ + FUEL_TANK_CENTER2_QUANTITY: { + name: 'FUEL TANK CENTER2 QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of center tank 1/2/3. */ + FUEL_TANK_CENTER3_QUANTITY: { + name: 'FUEL TANK CENTER3 QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Maximum capacity in volume of external tank 1/2. */ + FUEL_TANK_EXTERNAL1_CAPACITY: { + name: 'FUEL TANK EXTERNAL1 CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Maximum capacity in volume of external tank 1/2. */ + FUEL_TANK_EXTERNAL2_CAPACITY: { + name: 'FUEL TANK EXTERNAL2 CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of maximum capacity of texternal tank 1/2. */ + FUEL_TANK_EXTERNAL1_LEVEL: { + name: 'FUEL TANK EXTERNAL1 LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent of maximum capacity of texternal tank 1/2. */ + FUEL_TANK_EXTERNAL2_LEVEL: { + name: 'FUEL TANK EXTERNAL2 LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of external tank 1/2. */ + FUEL_TANK_EXTERNAL1_QUANTITY: { + name: 'FUEL TANK EXTERNAL1 QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of external tank 1/2. */ + FUEL_TANK_EXTERNAL2_QUANTITY: { + name: 'FUEL TANK EXTERNAL2 QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Maximum capacity in volume of the left auxiliary tank. */ + FUEL_TANK_LEFT_AUX_CAPACITY: { + name: 'FUEL TANK LEFT AUX CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of maximum capacity of the left auxiliary tank. */ + FUEL_TANK_LEFT_AUX_LEVEL: { + name: 'FUEL TANK LEFT AUX LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of the left auxiliary tank. */ + FUEL_TANK_LEFT_AUX_QUANTITY: { + name: 'FUEL TANK LEFT AUX QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Maximum capacity in volume of the left main tank. */ + FUEL_TANK_LEFT_MAIN_CAPACITY: { + name: 'FUEL TANK LEFT MAIN CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of maximum capacity of the left main tank. */ + FUEL_TANK_LEFT_MAIN_LEVEL: { + name: 'FUEL TANK LEFT MAIN LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of the left main tank. */ + FUEL_TANK_LEFT_MAIN_QUANTITY: { + name: 'FUEL TANK LEFT MAIN QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Maximum capacity in volume of the left tip tank. */ + FUEL_TANK_LEFT_TIP_CAPACITY: { + name: 'FUEL TANK LEFT TIP CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of maximum capacity of the left tip tank. */ + FUEL_TANK_LEFT_TIP_LEVEL: { + name: 'FUEL TANK LEFT TIP LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of the left tip tank. */ + FUEL_TANK_LEFT_TIP_QUANTITY: { + name: 'FUEL TANK LEFT TIP QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Maximum capacity in volume of the right auxiliary tank. */ + FUEL_TANK_RIGHT_AUX_CAPACITY: { + name: 'FUEL TANK RIGHT AUX CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of maximum capacity of the right auxiliary tank. */ + FUEL_TANK_RIGHT_AUX_LEVEL: { + name: 'FUEL TANK RIGHT AUX LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of the right auxiliary tank. */ + FUEL_TANK_RIGHT_AUX_QUANTITY: { + name: 'FUEL TANK RIGHT AUX QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Maximum capacity in volume of the right main tank. */ + FUEL_TANK_RIGHT_MAIN_CAPACITY: { + name: 'FUEL TANK RIGHT MAIN CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of maximum capacity of the right main tank. */ + FUEL_TANK_RIGHT_MAIN_LEVEL: { + name: 'FUEL TANK RIGHT MAIN LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of the right main tank. */ + FUEL_TANK_RIGHT_MAIN_QUANTITY: { + name: 'FUEL TANK RIGHT MAIN QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Maximum capacity in volume of the right tip tank. */ + FUEL_TANK_RIGHT_TIP_CAPACITY: { + name: 'FUEL TANK RIGHT TIP CAPACITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent of maximum capacity of the right tip tank. */ + FUEL_TANK_RIGHT_TIP_LEVEL: { + name: 'FUEL TANK RIGHT TIP LEVEL', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current quantity in volume of the right tip tank. */ + FUEL_TANK_RIGHT_TIP_QUANTITY: { + name: 'FUEL TANK RIGHT TIP QUANTITY', + units: 'Gallons', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Which tank the indexed selector is set to. The index is the selector to check (from 1 to 4), and the return value will be the +Fuel Tank Selection index. + NOTE: This SimVar is only valid for the legacy [FUEL] +setup. */ + 'FUEL_TANK_SELECTOR:index': { + name: 'FUEL TANK SELECTOR:index', + units: 'Enum', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the aircraft is in a cloud. */ + AMBIENT_IN_CLOUD: { + name: 'AMBIENT IN CLOUD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the aircraft has met the conditions required to spawn the contrail VFX. */ + CONTRAILS_CONDITIONS_MET: { + name: 'CONTRAILS CONDITIONS MET', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if slew is active. */ + IS_SLEW_ACTIVE: { + name: 'IS SLEW ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** True if slew is enabled. */ + IS_SLEW_ALLOWED: { + name: 'IS SLEW ALLOWED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Is this the user loaded aircraft. */ + IS_USER_SIM: { + name: 'IS USER SIM', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the plane is currently on a runway. */ + ON_ANY_RUNWAY: { + name: 'ON ANY RUNWAY', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the plane is currently parked (true) or not (false). */ + PLANE_IN_PARKING_STATE: { + name: 'PLANE IN PARKING STATE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The state of the surface directly under the aircraft. */ + SURFACE_CONDITION: { + name: 'SURFACE CONDITION', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True indicates that the SURFACE CONDITION return value is meaningful. */ + SURFACE_INFO_VALID: { + name: 'SURFACE INFO VALID', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The type of surface under the aircraft. */ + SURFACE_TYPE: { + name: 'SURFACE TYPE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Amount of ice on aircraft structure. 100 is fully iced. */ + STRUCTURAL_ICE_PCT: { + name: 'STRUCTURAL ICE PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Title from aircraft.cfg. */ + TITLE: { + name: 'TITLE', + units: 'String', + dataType: SimConnectDataType.STRING8, + settable: false, + }, + /** True if a towline is connected to both tow plane and glider. */ + TOW_CONNECTION: { + name: 'TOW CONNECTION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is visual effect available on this aircraft. */ + WINDSHIELD_RAIN_EFFECT_AVAILABLE: { + name: 'WINDSHIELD RAIN EFFECT AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Acceleration relative to aircraft X axis, in east/west direction. */ + ACCELERATION_BODY_X: { + name: 'ACCELERATION BODY X', + units: 'Feet (ft) per second squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Acceleration relative to aircraft Y axis, in vertical direction. */ + ACCELERATION_BODY_Y: { + name: 'ACCELERATION BODY Y', + units: 'Feet (ft) per second squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Acceleration relative to aircraft Z axis, in north/south direction. */ + ACCELERATION_BODY_Z: { + name: 'ACCELERATION BODY Z', + units: 'Feet (ft) per second squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Acceleration relative to the earth X axis, in east/west direction. */ + ACCELERATION_WORLD_X: { + name: 'ACCELERATION WORLD X', + units: 'Feet (ft) per second squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Acceleration relative to the earth Y axis, in vertical direction. */ + ACCELERATION_WORLD_Y: { + name: 'ACCELERATION WORLD Y', + units: 'Feet (ft) per second squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Acceleration relative to the earth Z axis, in north/south direction. */ + ACCELERATION_WORLD_Z: { + name: 'ACCELERATION WORLD Z', + units: 'Feet (ft) per second squared', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The speed of the aircraft relative to the speed of the first surface directly underneath it. Use this to retrieve, for example, an aircraft's taxiing speed while it is moving on a moving carrier. It also applies to airborne aircraft, for example when a helicopter is successfully hovering above a moving ship, this value should be zero. The returned value will be the same as GROUND VELOCITY if the first surface beneath it is not moving. */ + SURFACE_RELATIVE_GROUND_SPEED: { + name: 'SURFACE RELATIVE GROUND SPEED', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Speed relative to the earths surface. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + GROUND_VELOCITY: { + name: 'GROUND VELOCITY', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Altitude of aircraft. */ + PLANE_ALTITUDE: { + name: 'PLANE ALTITUDE', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Altitude above the surface. */ + PLANE_ALT_ABOVE_GROUND: { + name: 'PLANE ALT ABOVE GROUND', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Altitude above the surface minus CG. */ + PLANE_ALT_ABOVE_GROUND_MINUS_CG: { + name: 'PLANE ALT ABOVE GROUND MINUS CG', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Bank angle, although the name mentions degrees the units used are radians. */ + PLANE_BANK_DEGREES: { + name: 'PLANE BANK DEGREES', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Heading indicator (directional gyro) indication. */ + PLANE_HEADING_DEGREES_GYRO: { + name: 'PLANE HEADING DEGREES GYRO', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Heading relative to magnetic north - although the name mentions degrees the units used are radians. */ + PLANE_HEADING_DEGREES_MAGNETIC: { + name: 'PLANE HEADING DEGREES MAGNETIC', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Heading relative to true north - although the name mentions degrees the units used are radians. */ + PLANE_HEADING_DEGREES_TRUE: { + name: 'PLANE HEADING DEGREES TRUE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Latitude of aircraft, North is positive, South negative. */ + PLANE_LATITUDE: { + name: 'PLANE LATITUDE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Longitude of aircraft, East is positive, West negative. */ + PLANE_LONGITUDE: { + name: 'PLANE LONGITUDE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Pitch angle, although the name mentions degrees the units used are radians. */ + PLANE_PITCH_DEGREES: { + name: 'PLANE PITCH DEGREES', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This float represents the bank of the player's plane from the last touchdown. */ + PLANE_TOUCHDOWN_BANK_DEGREES: { + name: 'PLANE TOUCHDOWN BANK DEGREES', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the magnetic heading of the player's plane from the last touchdown. */ + PLANE_TOUCHDOWN_HEADING_DEGREES_MAGNETIC: { + name: 'PLANE TOUCHDOWN HEADING DEGREES MAGNETIC', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the true heading of the player's plane from the last touchdown. */ + PLANE_TOUCHDOWN_HEADING_DEGREES_TRUE: { + name: 'PLANE TOUCHDOWN HEADING DEGREES TRUE', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the plane latitude for the last touchdown. */ + PLANE_TOUCHDOWN_LATITUDE: { + name: 'PLANE TOUCHDOWN LATITUDE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the plane longitude for the last touchdown. */ + PLANE_TOUCHDOWN_LONGITUDE: { + name: 'PLANE TOUCHDOWN LONGITUDE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the player's plane speed according to ground normal from the last touchdown. */ + PLANE_TOUCHDOWN_NORMAL_VELOCITY: { + name: 'PLANE TOUCHDOWN NORMAL VELOCITY', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the pitch of the player's plane from the last touchdown. */ + PLANE_TOUCHDOWN_PITCH_DEGREES: { + name: 'PLANE TOUCHDOWN PITCH DEGREES', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Lateral (X axis) speed relative to wind. */ + RELATIVE_WIND_VELOCITY_BODY_X: { + name: 'RELATIVE WIND VELOCITY BODY X', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Vertical (Y axis) speed relative to wind. */ + RELATIVE_WIND_VELOCITY_BODY_Y: { + name: 'RELATIVE WIND VELOCITY BODY Y', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Longitudinal (Z axis) speed relative to wind. */ + RELATIVE_WIND_VELOCITY_BODY_Z: { + name: 'RELATIVE WIND VELOCITY BODY Z', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Rotation acceleration relative to aircraft X axis. */ + ROTATION_ACCELERATION_BODY_X: { + name: 'ROTATION ACCELERATION BODY X', + units: 'Radians per second squared', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Rotation acceleration relative to aircraft Y axis. */ + ROTATION_ACCELERATION_BODY_Y: { + name: 'ROTATION ACCELERATION BODY Y', + units: 'Radians per second squared', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Rotation acceleration relative to aircraft Z axis. */ + ROTATION_ACCELERATION_BODY_Z: { + name: 'ROTATION ACCELERATION BODY Z', + units: 'Radians per second squared', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Rotation velocity relative to aircraft X axis. */ + ROTATION_VELOCITY_BODY_X: { + name: 'ROTATION VELOCITY BODY X', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Rotation velocity relative to aircraft Y axis. */ + ROTATION_VELOCITY_BODY_Y: { + name: 'ROTATION VELOCITY BODY Y', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Rotation velocity relative to aircraft Z axis. */ + ROTATION_VELOCITY_BODY_Z: { + name: 'ROTATION VELOCITY BODY Z', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The slope between the plane and the expected landing position of the runway. Returns 0 if no runway is assigned. */ + SLOPE_TO_ATC_RUNWAY: { + name: 'SLOPE TO ATC RUNWAY', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True lateral speed, relative to aircraft X axis. */ + VELOCITY_BODY_X: { + name: 'VELOCITY BODY X', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True vertical speed, relative to aircraft Y axis. */ + VELOCITY_BODY_Y: { + name: 'VELOCITY BODY Y', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True longitudinal speed, relative to aircraft Z axis. */ + VELOCITY_BODY_Z: { + name: 'VELOCITY BODY Z', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The current indicated vertical speed for the aircraft. */ + VERTICAL_SPEED: { + name: 'VERTICAL SPEED', + units: 'Feet (ft) per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The eyepoint position relative to the reference datum position for the aircraft. */ + EYEPOINT_POSITION: { + name: 'EYEPOINT POSITION', + units: 'SIMCONNECT_DATA_XYZ', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** Returns the various airspeed PID constants. This is generally only used for AI controlled aircraft and boats, although it may be useful when working with RTCs and the user aircraft. */ + STRUC_AIRSPEED_HOLD_PID_CONSTS: { + name: 'STRUC AIRSPEED HOLD PID CONSTS', + units: 'PID_STRUCT', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the various airspeed PID constants. This is generally only used for AI controlled aircraft and boats, although it may be useful when working with RTCs and the user aircraft. */ + STRUC_HEADING_HOLD_PID_CONSTS: { + name: 'STRUC HEADING HOLD PID CONSTS', + units: 'PID_STRUCT', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The body rotation acceleration. */ + STRUCT_BODY_ROTATION_ACCELERATION: { + name: 'STRUCT BODY ROTATION ACCELERATION', + units: 'SIMCONNECT_DATA_XYZ', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** The body rotation velocity. */ + STRUCT_BODY_ROTATION_VELOCITY: { + name: 'STRUCT BODY ROTATION VELOCITY', + units: 'SIMCONNECT_DATA_XYZ', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** The object body velocity. */ + STRUCT_BODY_VELOCITY: { + name: 'STRUCT BODY VELOCITY', + units: 'SIMCONNECT_DATA_XYZ', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** The position of the indexed engine relative to the Datum Reference Point for the aircraft. */ + 'STRUCT_ENGINE_POSITION:index': { + name: 'STRUCT ENGINE POSITION:index', + units: 'SIMCONNECT_DATA_XYZ', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** The angle of the eyepoint view. Zero, zero, zero is straight ahead. */ + STRUCT_EYEPOINT_DYNAMIC_ANGLE: { + name: 'STRUCT EYEPOINT DYNAMIC ANGLE', + units: 'SIMCONNECT_DATA_XYZ', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** A variable offset away from the EYEPOINT POSITION. */ + STRUCT_EYEPOINT_DYNAMIC_OFFSET: { + name: 'STRUCT EYEPOINT DYNAMIC OFFSET', + units: 'SIMCONNECT_DATA_XYZ', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** Returns the latitude, longitude and altitude of the user aircraft. */ + STRUCT_LATLONALT: { + name: 'STRUCT LATLONALT', + units: 'SIMCONNECT_DATA_LATLONALT', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** Returns the lattitude, longitude, altitude, pitch, bank and heading of the user aircraft. */ + STRUCT_LATLONALTPBH: { + name: 'STRUCT LATLONALTPBH', + units: 'Returns a struct with 6 values: lat, lon, alt, pitch, bank, heading', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Wind component in aircraft lateral (X) axis. */ + AIRCRAFT_WIND_X: { + name: 'AIRCRAFT WIND X', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Wind component in aircraft vertical (Y) axis. */ + AIRCRAFT_WIND_Y: { + name: 'AIRCRAFT WIND Y', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Wind component in aircraft longitudinal (Z) axis. */ + AIRCRAFT_WIND_Z: { + name: 'AIRCRAFT WIND Z', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Redline airspeed (dynamic on some aircraft). */ + AIRSPEED_BARBER_POLE: { + name: 'AIRSPEED BARBER POLE', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Indicated airspeed. */ + AIRSPEED_INDICATED: { + name: 'AIRSPEED INDICATED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current mach. */ + AIRSPEED_MACH: { + name: 'AIRSPEED MACH', + units: 'Mach', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The airspeed, whether true or indicated airspeed has been selected. */ + AIRSPEED_SELECT_INDICATED_OR_TRUE: { + name: 'AIRSPEED SELECT INDICATED OR TRUE', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True airspeed. */ + AIRSPEED_TRUE: { + name: 'AIRSPEED TRUE', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Equivalent to AIRSPEED TRUE, but does not account for wind when used to Set Airspeed value */ + AIRSPEED_TRUE_RAW: { + name: 'AIRSPEED TRUE RAW', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Mach associated with maximum airspeed. */ + BARBER_POLE_MACH: { + name: 'BARBER POLE MACH', + units: 'Mach', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Velocity regardless of direction. For example, if a helicopter is ascending vertically at 100 fps, getting this variable will return 100. */ + TOTAL_VELOCITY: { + name: 'TOTAL VELOCITY', + units: 'Feet (ft per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Longitudinal speed of wind on the windshield. */ + WINDSHIELD_WIND_VELOCITY: { + name: 'WINDSHIELD WIND VELOCITY', + units: 'Feet (ft per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Outside temperature on the standard ATM scale. */ + STANDARD_ATM_TEMPERATURE: { + name: 'STANDARD ATM TEMPERATURE', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Total air temperature is the air temperature at the front of the aircraft where the ram pressure from the speed of the aircraft is taken into account. */ + TOTAL_AIR_TEMPERATURE: { + name: 'TOTAL AIR TEMPERATURE', + units: 'Celsius', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** ADF frequency. Index of 1 or 2. */ + 'ADF_ACTIVE_FREQUENCY:index': { + name: 'ADF ACTIVE FREQUENCY:index', + units: 'Frequency ADF BCD32', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if ADF is available */ + 'ADF_AVAILABLE:index': { + name: 'ADF AVAILABLE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** ADF compass rose setting */ + ADF_CARD: { + name: 'ADF CARD', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, use ADF ACTIVE FREQUENCY */ + ADF_EXT_FREQUENCY: { + name: 'ADF EXT FREQUENCY', + units: 'Frequency BCD16', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, use ADF ACTIVE FREQUENCY */ + ADF_FREQUENCY: { + name: 'ADF FREQUENCY', + units: 'Frequency BCD16', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** ICAO code */ + ADF_IDENT: { + name: 'ADF IDENT', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Returns the latitude, longitude and altitude of the station the radio equipment is currently tuned to, or zeros if the radio is not tuned to any ADF station. Index of 1 or 2 for ADF 1 and ADF 2. */ + 'ADF_LATLONALT:index': { + name: 'ADF LATLONALT:index', + units: 'SIMCONNECT_DATA_LATLONALT', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** Descriptive name */ + 'ADF_NAME:index': { + name: 'ADF NAME:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Current direction from NDB station */ + 'ADF_RADIAL:index': { + name: 'ADF RADIAL:index', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the magnetic bearing to the currently tuned ADF transmitter. */ + 'ADF_RADIAL_MAG:index': { + name: 'ADF RADIAL MAG:index', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Signal strength */ + 'ADF_SIGNAL:index': { + name: 'ADF SIGNAL:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** ADF audio flag. Index of 0 or 1. */ + 'ADF_SOUND:index': { + name: 'ADF SOUND:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if ADF Standby is available */ + 'ADF_STANDBY_AVAILABLE:index': { + name: 'ADF STANDBY AVAILABLE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** ADF standby frequency */ + 'ADF_STANDBY_FREQUENCY:index': { + name: 'ADF STANDBY FREQUENCY:index', + units: 'Hz', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the volume of the ADF */ + ADF_VOLUME: { + name: 'ADF VOLUME', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The name of the Airline used by ATC, as a string with a maximum length of 50 characters. */ + ATC_AIRLINE: { + name: 'ATC AIRLINE', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: true, + }, + /** If the airport is controlled, this boolean is true. */ + ATC_AIRPORT_IS_TOWERED: { + name: 'ATC AIRPORT IS TOWERED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether or not the user has filed an IFR flightplan that has been cleared by the sim ATC */ + ATC_CLEARED_IFR: { + name: 'ATC CLEARED IFR', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether the ATC has cleared the plane for landing. */ + ATC_CLEARED_LANDING: { + name: 'ATC CLEARED LANDING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether the ATC has cleared the plane for takeoff. */ + ATC_CLEARED_TAKEOFF: { + name: 'ATC CLEARED TAKEOFF', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether the ATC has cleared the plane for taxi. */ + ATC_CLEARED_TAXI: { + name: 'ATC CLEARED TAXI', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the target altitude for the current ATC flightplan waypoint. */ + ATC_CURRENT_WAYPOINT_ALTITUDE: { + name: 'ATC CURRENT WAYPOINT ALTITUDE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Flight Number used by ATC, as a string with a maximum number of 6 characters. */ + ATC_FLIGHT_NUMBER: { + name: 'ATC FLIGHT NUMBER', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: true, + }, + /** Altitude between the position of the aircraft and his closest waypoints in the flightplan. */ + ATC_FLIGHTPLAN_DIFF_ALT: { + name: 'ATC FLIGHTPLAN DIFF ALT', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the lateral distance the user's plane is from the ATC flight plan track. */ + ATC_FLIGHTPLAN_DIFF_DISTANCE: { + name: 'ATC FLIGHTPLAN DIFF DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Heading between the position of the aircraft and his closest waypoints in the flightplan. */ + ATC_FLIGHTPLAN_DIFF_HEADING: { + name: 'ATC FLIGHTPLAN DIFF HEADING', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Is this aircraft recognized by ATC as heavy. */ + ATC_HEAVY: { + name: 'ATC HEAVY', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** ID used by ATC, as a string with a maximum number of 10 characters. */ + ATC_ID: { + name: 'ATC ID', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: true, + }, + /** Returns true if the user has a valid IFR flight plan they can as for clearance for with ATC at the airport they are currently at. */ + ATC_IFR_FP_TO_REQUEST: { + name: 'ATC IFR FP TO REQUEST', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Model used by ATC, as a string with a maximum number of 10 characters. */ + ATC_MODEL: { + name: 'ATC MODEL', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Is ATC aircraft on parking spot. */ + ATC_ON_PARKING_SPOT: { + name: 'ATC ON PARKING SPOT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the target altitude for the previous ATC flightplan waypoint. */ + ATC_PREVIOUS_WAYPOINT_ALTITUDE: { + name: 'ATC PREVIOUS WAYPOINT ALTITUDE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The name of the airport of the runway assigned by the ATC. Returns "" if no runway is assigned. */ + ATC_RUNWAY_AIRPORT_NAME: { + name: 'ATC RUNWAY AIRPORT NAME', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** This float represents the distance between the player's plane and the center of the runway selected by the ATC. */ + ATC_RUNWAY_DISTANCE: { + name: 'ATC RUNWAY DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This is a float corresponding to the horizontal distance between the player's plane and the end of the runway selected by the ATC. */ + ATC_RUNWAY_END_DISTANCE: { + name: 'ATC RUNWAY END DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the true heading of the runway selected by the ATC. */ + ATC_RUNWAY_HEADING_DEGREES_TRUE: { + name: 'ATC RUNWAY HEADING DEGREES TRUE', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The length of the runway assigned by the ATC. Returns -1 if no runway is assigned. */ + ATC_RUNWAY_LENGTH: { + name: 'ATC RUNWAY LENGTH', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This is a float corresponding to the player's main gear relative X (transverse) position on the runway selected by the ATC. */ + ATC_RUNWAY_RELATIVE_POSITION_X: { + name: 'ATC RUNWAY RELATIVE POSITION X', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This is a float corresponding to the player's main gear relative Y (height) position on the runway selected by the ATC. */ + ATC_RUNWAY_RELATIVE_POSITION_Y: { + name: 'ATC RUNWAY RELATIVE POSITION Y', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This is a float corresponding to the player's main gear relative Z (longitudinal) position on the runway selected by the ATC. */ + ATC_RUNWAY_RELATIVE_POSITION_Z: { + name: 'ATC RUNWAY RELATIVE POSITION Z', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This is a boolean corresponding to whether or not the ATC has pre-selected a runway for the player's plane. If this is false, every other ATC RUNWAY +* +SimVar will return default values. */ + ATC_RUNWAY_SELECTED: { + name: 'ATC RUNWAY SELECTED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is a float corresponding to the horizontal distance between the player's plane and the start of the runway selected by the ATC. */ + ATC_RUNWAY_START_DISTANCE: { + name: 'ATC RUNWAY START DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the player's main gear relative X (transverse) position according to the aiming point of the runway selected by the ATC. */ + ATC_RUNWAY_TDPOINT_RELATIVE_POSITION_X: { + name: 'ATC RUNWAY TDPOINT RELATIVE POSITION X', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the player's main gear relative Y (height) position according to the aiming point of the runway selected by the ATC. */ + ATC_RUNWAY_TDPOINT_RELATIVE_POSITION_Y: { + name: 'ATC RUNWAY TDPOINT RELATIVE POSITION Y', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This float represents the player's main relative Z (longitudinal) position according to the aiming point of the runway selected by the ATC. */ + ATC_RUNWAY_TDPOINT_RELATIVE_POSITION_Z: { + name: 'ATC RUNWAY TDPOINT RELATIVE POSITION Z', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The width of the runway assigned by the ATC. Returns -1 if no runway is assigned. */ + ATC_RUNWAY_WIDTH: { + name: 'ATC RUNWAY WIDTH', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Suggested minimum runway length for landing. Used by ATC. */ + ATC_SUGGESTED_MIN_RWY_LANDING: { + name: 'ATC SUGGESTED MIN RWY LANDING', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Suggested minimum runway length for takeoff. Used by ATC. */ + ATC_SUGGESTED_MIN_RWY_TAKEOFF: { + name: 'ATC SUGGESTED MIN RWY TAKEOFF', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the lateral distance the user's plane is from the path of the currently issued ATC taxi instructions. */ + ATC_TAXIPATH_DISTANCE: { + name: 'ATC TAXIPATH DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Type used by ATC. */ + ATC_TYPE: { + name: 'ATC TYPE', + units: 'String (30)', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The stored COM 1/2/3 frequency value. */ + COM1_STORED_FREQUENCY: { + name: 'COM1 STORED FREQUENCY', + units: 'Frequency BCD16', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The stored COM 1/2/3 frequency value. */ + COM2_STORED_FREQUENCY: { + name: 'COM2 STORED FREQUENCY', + units: 'Frequency BCD16', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The stored COM 1/2/3 frequency value. */ + COM3_STORED_FREQUENCY: { + name: 'COM3 STORED FREQUENCY', + units: 'Frequency BCD16', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Gives the bearing (in degrees) of the active COM station (airport) or a value less than 0 if the station does not belong to an airport. Index is 1, 2 or 3. */ + 'COM_ACTIVE_BEARING:index': { + name: 'COM ACTIVE BEARING:index', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Gives the distance (in meters) to the active COM station (airport) or a value less than -180° if the station does not belong to an airport. Index is 1, 2 or 3. */ + 'COM_ACTIVE_DISTANCE:index': { + name: 'COM ACTIVE DISTANCE:index', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Com frequency. Index is 1, 2 or 3. */ + 'COM_ACTIVE_FREQUENCY:index': { + name: 'COM ACTIVE FREQUENCY:index', + units: 'Frequency BCD16', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The identity of the station that is tuned on the indexed active COM radio. Index is 1, 2, or 3. */ + 'COM_ACTIVE_FREQ_IDENT:index': { + name: 'COM ACTIVE FREQ IDENT:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The type of COM frequency for the active indexed COM system. Index is 1, 2, or 3. */ + 'COM_ACTIVE_FREQ_TYPE:index': { + name: 'COM ACTIVE FREQ TYPE:index', + units: 'String:', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** This will return the latitude, longitude and altitude corresponding to the indexed COM station associated with the active COM frequency. If the station is not associated with an airport, then the lat/lon/alt values returned will be -15943°, 80°, -10000 (this means that you can simply check that the altitude value is greater than 0 to assure the validity of the returned struct). + Index is 1, 2 or 3. */ + 'COM_ACTIVE_LATLONALT:index': { + name: 'COM ACTIVE LATLONALT:index', + units: 'Struct:', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** True if COM1, COM2 or COM3 is available (depending on the index, either 1, 2, or 3) */ + 'COM_AVAILABLE:index': { + name: 'COM AVAILABLE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Not currently used in the simulation. */ + 'COM_LATLONALT:index': { + name: 'COM LATLONALT:index', + units: 'Struct:', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** Whether or not the plane is receiving on the indexed com channel or not (either 1, 2, or 3 for the index). */ + 'COM_RECEIVE:index': { + name: 'COM RECEIVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Toggles all COM radios to receive on */ + COM_RECEIVE_ALL: { + name: 'COM RECEIVE ALL', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the plane is receiving on the indexed com channel. Index is 1, 2 or 3. */ + 'COM_RECEIVE_EX1:index': { + name: 'COM RECEIVE EX1:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The COM radio frequency step. Index is 1, 2 or 3. */ + 'COM_SPACING_MODE:index': { + name: 'COM SPACING MODE:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Com standby frequency. Index is 1, 2 or 3. */ + 'COM_STANDBY_FREQUENCY:index': { + name: 'COM STANDBY FREQUENCY:index', + units: 'Frequency BCD16', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The identity of the station that is tuned on the indexed standby COM radio. Index is 1, 2, or 3. */ + 'COM_STANDBY_FREQ_IDENT:index': { + name: 'COM STANDBY FREQ IDENT:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The type of COM frequency for the standby indexed COM system. Index is 1, 2, or 3. */ + 'COM_STANDBY_FREQ_TYPE:index': { + name: 'COM STANDBY FREQ TYPE:index', + units: 'String:', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Radio status flag for the indexed com channel. Index is 1, 2 or 3. */ + 'COM_STATUS:index': { + name: 'COM STATUS:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Enter an index of 1, 2 or 3. Will return TRUE if the COM system is working, FALSE otherwise. */ + 'COM_TEST:index': { + name: 'COM TEST:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Audio panel com transmit state. Index of 1, 2 or 3. */ + 'COM_TRANSMIT:index': { + name: 'COM TRANSMIT:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The volume of the COM Radio. */ + COM_VOLUME: { + name: 'COM VOLUME', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether the FLARM is available (TRUE, 1) or not (FALSE, 0). */ + FLARM_AVAILABLE: { + name: 'FLARM AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The bearing of the FLARM threat aircraft, relative to track. */ + FLARM_THREAT_BEARING: { + name: 'FLARM THREAT BEARING', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The FLARM threat aircraft data structure, which contains data about the perceived threat, returned as a struct. Struct member variables are as follows: + + id +(U62): the network id of the intruding plane so that they are remembered in order to compute their trajectory. + bearing +(FLOAT64): The threat bearing, in degrees (this is bearing from track axis and not bearing from the airplane axis). + heading +(FLOAT64): The threat heading. + distance +(FLOAT64): +The distance between the aircraft and the threat, in meters. + verticalBearing +(FLOAT64): +The vertical bearing between the aircraft and the threat, in degrees. + relativeAltitude +(FLOAT64): +The relative altitude of the threat to the aircraft, in meters. + timeToCollision +(FLOAT64): +The estimated time to a collision, in seconds. */ + FLARM_THREAT_DATA: { + name: 'FLARM THREAT DATA', + units: 'Struct', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The distance to the FLARM threat object. */ + FLARM_THREAT_DISTANCE: { + name: 'FLARM THREAT DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The heading to the FLARM threat object. */ + FLARM_THREAT_HEADING: { + name: 'FLARM THREAT HEADING', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The relative altitude of the threat object. */ + FLARM_THREAT_RELATIVE_ALTITUDE: { + name: 'FLARM THREAT RELATIVE ALTITUDE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The estimated time to a collision. */ + FLARM_THREAT_TIME_TO_COLLISION: { + name: 'FLARM THREAT TIME TO COLLISION', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The vertical bearing towards the threat. */ + FLARM_THREAT_VERTICAL_BEARING: { + name: 'FLARM THREAT VERTICAL BEARING', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** ID of airport. */ + GPS_APPROACH_AIRPORT_ID: { + name: 'GPS APPROACH AIRPORT ID', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** ID of approach. */ + GPS_APPROACH_APPROACH_ID: { + name: 'GPS APPROACH APPROACH ID', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Index of approach for given airport. */ + GPS_APPROACH_APPROACH_INDEX: { + name: 'GPS APPROACH APPROACH INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Approach type. */ + GPS_APPROACH_APPROACH_TYPE: { + name: 'GPS APPROACH APPROACH TYPE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Is approach transition final approach segment. */ + GPS_APPROACH_IS_FINAL: { + name: 'GPS APPROACH IS FINAL', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Is approach segment missed approach segment. */ + GPS_APPROACH_IS_MISSED: { + name: 'GPS APPROACH IS MISSED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Waypoint is the runway. */ + GPS_APPROACH_IS_WP_RUNWAY: { + name: 'GPS APPROACH IS WP RUNWAY', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Sub mode within approach mode. */ + GPS_APPROACH_MODE: { + name: 'GPS APPROACH MODE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Segment type within approach. */ + GPS_APPROACH_SEGMENT_TYPE: { + name: 'GPS APPROACH SEGMENT TYPE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Deviation of local time from GMT. */ + GPS_APPROACH_TIMEZONE_DEVIATION: { + name: 'GPS APPROACH TIMEZONE DEVIATION', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** ID of approach transition. */ + GPS_APPROACH_TRANSITION_ID: { + name: 'GPS APPROACH TRANSITION ID', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Index of approach transition. */ + GPS_APPROACH_TRANSITION_INDEX: { + name: 'GPS APPROACH TRANSITION INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Number of waypoints. */ + GPS_APPROACH_WP_COUNT: { + name: 'GPS APPROACH WP COUNT', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Index of current waypoint. */ + GPS_APPROACH_WP_INDEX: { + name: 'GPS APPROACH WP INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Waypoint type within approach mode. */ + GPS_APPROACH_WP_TYPE: { + name: 'GPS APPROACH WP TYPE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The course deviation of the needle for a CDI instrument. The SimVar displays the deviation from -127 to +127. It returns a value if a flight plan is set (otherwise it will return 0) even if the autopilot isn't on GPS mode. Scaling can also be set through the GPS CDI SCALING simvar. */ + GPS_CDI_NEEDLE: { + name: 'GPS CDI NEEDLE', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The full scale deflection of the CDI due to GPS cross-track error, in meters. */ + GPS_CDI_SCALING: { + name: 'GPS CDI SCALING', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Suggested heading to steer (for autopilot). */ + GPS_COURSE_TO_STEER: { + name: 'GPS COURSE TO STEER', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** GPS is driving Nav 1 indicator. Note this setting will also affect the SimVars HSI_STATION_IDENT and HSI_BEARING. */ + GPS_DRIVES_NAV1: { + name: 'GPS DRIVES NAV1', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Estimated time of arrival at destination. */ + GPS_ETA: { + name: 'GPS ETA', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Estimated time en route to destination. */ + GPS_ETE: { + name: 'GPS ETE', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This is the complete flightplan length from start to end. Essentially the cumulative length of all the flight plan legs added together. */ + GPS_FLIGHTPLAN_TOTAL_DISTANCE: { + name: 'GPS FLIGHTPLAN TOTAL DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Number of waypoints. */ + GPS_FLIGHT_PLAN_WP_COUNT: { + name: 'GPS FLIGHT PLAN WP COUNT', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Index of waypoint. */ + GPS_FLIGHT_PLAN_WP_INDEX: { + name: 'GPS FLIGHT PLAN WP INDEX', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current magnetic ground track. */ + GPS_GROUND_MAGNETIC_TRACK: { + name: 'GPS GROUND MAGNETIC TRACK', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current ground speed. */ + GPS_GROUND_SPEED: { + name: 'GPS GROUND SPEED', + units: 'Meters per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current true heading. */ + GPS_GROUND_TRUE_HEADING: { + name: 'GPS GROUND TRUE HEADING', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current true ground track. */ + GPS_GROUND_TRUE_TRACK: { + name: 'GPS GROUND TRUE TRACK', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The full scale deflection of the vertical GSI due to GPS glidepath deviation, in meters. */ + GPS_GSI_SCALING: { + name: 'GPS GSI SCALING', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Whether or not the GPS system has a presently available glidepath for guidance. Only applicable with GPS_OVERRIDDEN. When true and in GPS OVERRIDDEN, HSI_GSI_NEEDLE_VALID will also be true. */ + GPS_HAS_GLIDEPATH: { + name: 'GPS HAS GLIDEPATH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The glide deviation of the needle for a CDI instrument. The simvar displays the deviation from -127 to +127. It returns a value if a flight plan is set (otherwise it will return 0) even if the autopilot isn't on GPS mode. Scaling can also be set through the GPS CDI SCALING simvar. */ + GPS_HSI_NEEDLE: { + name: 'GPS HSI NEEDLE', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Flight plan mode active. */ + GPS_IS_ACTIVE_FLIGHT_PLAN: { + name: 'GPS IS ACTIVE FLIGHT PLAN', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Waypoint mode active. */ + GPS_IS_ACTIVE_WAY_POINT: { + name: 'GPS IS ACTIVE WAY POINT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Is switching to next waypoint locked. */ + GPS_IS_ACTIVE_WP_LOCKED: { + name: 'GPS IS ACTIVE WP LOCKED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is approach mode active. */ + GPS_IS_APPROACH_ACTIVE: { + name: 'GPS IS APPROACH ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is approach loaded. */ + GPS_IS_APPROACH_LOADED: { + name: 'GPS IS APPROACH LOADED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is flight plan destination reached. */ + GPS_IS_ARRIVED: { + name: 'GPS IS ARRIVED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Is Direct To Waypoint mode active. */ + GPS_IS_DIRECTTO_FLIGHTPLAN: { + name: 'GPS IS DIRECTTO FLIGHTPLAN', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Current GPS magnetic variation. */ + GPS_MAGVAR: { + name: 'GPS MAGVAR', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Whether or not the OBS mode is currently active (disable the automatic sequencing of waypoints in GPS flight plan). */ + GPS_OBS_ACTIVE: { + name: 'GPS OBS ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This is the currently selected OBS course in degrees, from 0 to 360. */ + GPS_OBS_VALUE: { + name: 'GPS OBS VALUE', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** When it is active, all sim GPS system updates are suspended. This must be set to TRUE to be able to correctly set to any other GPS SimVar. */ + GPS_OVERRIDDEN: { + name: 'GPS OVERRIDDEN', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Current GPS altitude. */ + GPS_POSITION_ALT: { + name: 'GPS POSITION ALT', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current GPS latitude. */ + GPS_POSITION_LAT: { + name: 'GPS POSITION LAT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current GPS longitude. */ + GPS_POSITION_LON: { + name: 'GPS POSITION LON', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Altitude of GPS target. */ + GPS_TARGET_ALTITUDE: { + name: 'GPS TARGET ALTITUDE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Distance to target. */ + GPS_TARGET_DISTANCE: { + name: 'GPS TARGET DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Glidepath in degrees. */ + GPS_VERTICAL_ANGLE: { + name: 'GPS VERTICAL ANGLE', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Vertical error in degrees from GlidePath. */ + GPS_VERTICAL_ANGLE_ERROR: { + name: 'GPS VERTICAL ANGLE ERROR', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Vertical deviation in meters from GlidePath. */ + GPS_VERTICAL_ERROR: { + name: 'GPS VERTICAL ERROR', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Magnetic bearing to waypoint. */ + GPS_WP_BEARING: { + name: 'GPS WP BEARING', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Cross track distance. */ + GPS_WP_CROSS_TRK: { + name: 'GPS WP CROSS TRK', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The required heading (magnetic) from the previous waypoint to the next waypoint. */ + GPS_WP_DESIRED_TRACK: { + name: 'GPS WP DESIRED TRACK', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Distance to waypoint. */ + GPS_WP_DISTANCE: { + name: 'GPS WP DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Estimated time of arrival at waypoint. */ + GPS_WP_ETA: { + name: 'GPS WP ETA', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Estimated time en route to waypoint. */ + GPS_WP_ETE: { + name: 'GPS WP ETE', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Altitude of next waypoint. */ + GPS_WP_NEXT_ALT: { + name: 'GPS WP NEXT ALT', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** ID of next GPS waypoint. */ + GPS_WP_NEXT_ID: { + name: 'GPS WP NEXT ID', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: true, + }, + /** Latitude of next waypoint. */ + GPS_WP_NEXT_LAT: { + name: 'GPS WP NEXT LAT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Longitude of next waypoint. */ + GPS_WP_NEXT_LON: { + name: 'GPS WP NEXT LON', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Altitude of previous waypoint. */ + GPS_WP_PREV_ALT: { + name: 'GPS WP PREV ALT', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** ID of previous GPS waypoint. */ + GPS_WP_PREV_ID: { + name: 'GPS WP PREV ID', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: true, + }, + /** Latitude of previous waypoint. */ + GPS_WP_PREV_LAT: { + name: 'GPS WP PREV LAT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Longitude of previous waypoint. */ + GPS_WP_PREV_LON: { + name: 'GPS WP PREV LON', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Is previous waypoint valid (i.e. current waypoint is not the first waypoint). */ + GPS_WP_PREV_VALID: { + name: 'GPS WP PREV VALID', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Tracking angle error to waypoint. */ + GPS_WP_TRACK_ANGLE_ERROR: { + name: 'GPS WP TRACK ANGLE ERROR', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True bearing to waypoint. */ + GPS_WP_TRUE_BEARING: { + name: 'GPS WP TRUE BEARING', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Required true heading to waypoint. */ + GPS_WP_TRUE_REQ_HDG: { + name: 'GPS WP TRUE REQ HDG', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Vertical speed to waypoint. */ + GPS_WP_VERTICAL_SPEED: { + name: 'GPS WP VERTICAL SPEED', + units: 'Meters per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** If the GPS_DRIVES_NAV1 variable is true and the HSI BEARING VALID variable is true, this variable contains the HSI needle bearing. If the GPS DRIVES NAV1 variable is false and the HSI BEARING VALID variable is true, this variable contains the ADF1 frequency. */ + HSI_BEARING: { + name: 'HSI BEARING', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This will return true if the HSI BEARING variable contains valid data. */ + HSI_BEARING_VALID: { + name: 'HSI BEARING VALID', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Needle deflection (+/- 127). */ + HSI_CDI_NEEDLE: { + name: 'HSI CDI NEEDLE', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Signal valid. */ + HSI_CDI_NEEDLE_VALID: { + name: 'HSI CDI NEEDLE VALID', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** DME/GPS distance. */ + HSI_DISTANCE: { + name: 'HSI DISTANCE', + units: 'Nautical miles', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Needle deflection (+/- 119). */ + HSI_GSI_NEEDLE: { + name: 'HSI GSI NEEDLE', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Signal valid. */ + HSI_GSI_NEEDLE_VALID: { + name: 'HSI GSI NEEDLE VALID', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Station is a localizer. */ + HSI_HAS_LOCALIZER: { + name: 'HSI HAS LOCALIZER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** DME/GPS speed. */ + HSI_SPEED: { + name: 'HSI SPEED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the ident of the the next GPS waypoint, if GPS_DRIVES_NAV1 is true. If GPS DRIVES NAV1 is false, it returns the identity of the station that is tuned on nav radio 1. */ + HSI_STATION_IDENT: { + name: 'HSI STATION IDENT', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Nav TO/FROM flag. */ + HSI_TF_FLAGS: { + name: 'HSI TF FLAGS', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Inner marker state. */ + INNER_MARKER: { + name: 'INNER MARKER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns the latitude, longitude and altitude of the inner marker of an approach to a runway, if the aircraft is within the required proximity, otherwise it will return zeros. */ + INNER_MARKER_LATLONALT: { + name: 'INNER MARKER LATLONALT', + units: 'SIMCONNECT_DATA_LATLONALT', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** True if Marker is available. */ + MARKER_AVAILABLE: { + name: 'MARKER AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the Marker Beacon is in High Sensitivity mode. */ + MARKER_BEACON_SENSITIVITY_HIGH: { + name: 'MARKER BEACON SENSITIVITY HIGH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Marker beacon state. */ + MARKER_BEACON_STATE: { + name: 'MARKER BEACON STATE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Whether or not the Marker Beacon is in Test/Mute mode. */ + MARKER_BEACON_TEST_MUTE: { + name: 'MARKER BEACON TEST MUTE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Marker audio flag. */ + MARKER_SOUND: { + name: 'MARKER SOUND', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Middle marker state. */ + MIDDLE_MARKER: { + name: 'MIDDLE MARKER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns the latitude, longitude and altitude of the middle marker. */ + MIDDLE_MARKER_LATLONALT: { + name: 'MIDDLE MARKER LATLONALT', + units: 'SIMCONNECT_DATA_LATLONALT', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** Outer marker state. */ + OUTER_MARKER: { + name: 'OUTER MARKER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns the latitude, longitude and altitude of the outer marker. */ + OUTER_MARKER_LATLONALT: { + name: 'OUTER MARKER LATLONALT', + units: 'SIMCONNECT_DATA_LATLONALT', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** Nav active frequency. Index is 1 or 2. */ + 'NAV_ACTIVE_FREQUENCY:index': { + name: 'NAV ACTIVE FREQUENCY:index', + units: 'MHz', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Flag if Nav equipped on aircraft. */ + 'NAV_AVAILABLE:index': { + name: 'NAV AVAILABLE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the listed bit flags. */ + 'NAV_BACK_COURSE_FLAGS:index': { + name: 'NAV BACK COURSE FLAGS:index', + units: 'Flags:', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** CDI needle deflection (+/- 127). */ + 'NAV_CDI:index': { + name: 'NAV CDI:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Closest DME distance. Requires an index value from 1 to 4 to set which NAV to target. + Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ + 'NAV_CLOSE_DME:index': { + name: 'NAV CLOSE DME:index', + units: 'Nautical miles', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Closest Localizer course frequency. Requires an index value from 1 to 4 to set which NAV to target. + Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ + 'NAV_CLOSE_FREQUENCY:index': { + name: 'NAV CLOSE FREQUENCY:index', + units: 'Hz', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** ICAO code. Requires an index value from 1 to 4 to set which NAV to target. + Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ + 'NAV_CLOSE_IDENT:index': { + name: 'NAV CLOSE IDENT:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Closest Localizer course heading. Requires an index value from 1 to 4 to set which NAV to target. + Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ + 'NAV_CLOSE_LOCALIZER:index': { + name: 'NAV CLOSE LOCALIZER:index', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Descriptive name. Requires an index value from 1 to 4 to set which NAV to target. + Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ + 'NAV_CLOSE_NAME:index': { + name: 'NAV CLOSE NAME:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Returns bit flags with the listed meaning. */ + NAV_CODES: { + name: 'NAV CODES', + units: 'Flags:', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** DME distance. */ + NAV_DME: { + name: 'NAV DME', + units: 'Nautical miles', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** DME speed. */ + NAV_DMESPEED: { + name: 'NAV DMESPEED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the DME station. */ + 'NAV_DME_LATLONALT:index': { + name: 'NAV DME LATLONALT:index', + units: 'SIMCONNECT_DATA_LATLONALT structure', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** Localizer course frequency */ + NAV_FREQUENCY: { + name: 'NAV FREQUENCY', + units: 'Hz', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The glide slope gradient. The value returned is an integer value formed as follows: + sin(slope) * 65536 * 2 + So, for example, a glide slope of 2.7º would return a value of 6174. TO get the value in degrees, then use +NAV_RAW_GLIDE_SLOPE instead. */ + NAV_GLIDE_SLOPE: { + name: 'NAV GLIDE SLOPE', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Difference between current position and glideslope angle. Note that this provides 32 bit floating point precision, rather than the 8 bit integer precision of NAV GSI. */ + NAV_GLIDE_SLOPE_ERROR: { + name: 'NAV GLIDE SLOPE ERROR', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The distance between the plane and the Glide beacon. */ + NAV_GLIDE_SLOPE_LENGTH: { + name: 'NAV GLIDE SLOPE LENGTH', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Glideslope needle deflection (+/- 119). Note that this provides only 8 bit precision, whereas NAV GLIDE SLOPE ERROR provides 32 bit floating point precision. */ + NAV_GSI: { + name: 'NAV GSI', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Glideslope flag. */ + NAV_GS_FLAG: { + name: 'NAV GS FLAG', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns the glide slope. */ + 'NAV_GS_LATLONALT:index': { + name: 'NAV GS LATLONALT:index', + units: 'SIMCONNECT_DATA_LATLONALT structure', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** Nav GS latitude, longitude, altitude. */ + NAV_GS_LLAF64: { + name: 'NAV GS LLAF64', + units: 'SIMCONNECT_DATA_LATLONALT structure', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** Flag if found a close station with a DME. */ + NAV_HAS_CLOSE_DME: { + name: 'NAV HAS CLOSE DME', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Flag if found a close localizer station. */ + NAV_HAS_CLOSE_LOCALIZER: { + name: 'NAV HAS CLOSE LOCALIZER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Flag if tuned station has a DME. */ + NAV_HAS_DME: { + name: 'NAV HAS DME', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Flag if tuned station has a glideslope. */ + NAV_HAS_GLIDE_SLOPE: { + name: 'NAV HAS GLIDE SLOPE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Flag if tuned station is a localizer. */ + NAV_HAS_LOCALIZER: { + name: 'NAV HAS LOCALIZER', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Flag if Nav has signal. */ + NAV_HAS_NAV: { + name: 'NAV HAS NAV', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Flag if Nav has a Tacan. */ + NAV_HAS_TACAN: { + name: 'NAV HAS TACAN', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** ICAO code. */ + NAV_IDENT: { + name: 'NAV IDENT', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Localizer course heading. */ + NAV_LOCALIZER: { + name: 'NAV LOCALIZER', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The airport ICAO ident for the localizer that is currently tuned on the nav radio (like 'EGLL' or 'KJFK') */ + NAV_LOC_AIRPORT_IDENT: { + name: 'NAV LOC AIRPORT IDENT', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The letter code for the runway that the currently tuned localizer is tuned to. */ + NAV_LOC_RUNWAY_DESIGNATOR: { + name: 'NAV LOC RUNWAY DESIGNATOR', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** NAV LOC RUNWAY NUMBER - The number portion of the runway that the currently tuned localizer is tuned to (so if the runway was 15L, this would be 15). */ + NAV_LOC_RUNWAY_NUMBER: { + name: 'NAV LOC RUNWAY NUMBER', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Magnetic variation of tuned Nav station. */ + NAV_MAGVAR: { + name: 'NAV MAGVAR', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Descriptive name. */ + NAV_NAME: { + name: 'NAV NAME', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** OBS setting. Index of 1 or 2. */ + NAV_OBS: { + name: 'NAV OBS', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Radial that aircraft is on. */ + NAV_RADIAL: { + name: 'NAV RADIAL', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Difference between current radial and OBS tuned radial. */ + NAV_RADIAL_ERROR: { + name: 'NAV RADIAL ERROR', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The glide slope angle. */ + NAV_RAW_GLIDE_SLOPE: { + name: 'NAV RAW GLIDE SLOPE', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Relative bearing to station. */ + NAV_RELATIVE_BEARING_TO_STATION: { + name: 'NAV RELATIVE BEARING TO STATION', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Nav signal strength. */ + NAV_SIGNAL: { + name: 'NAV SIGNAL', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Nav audio flag. Index of 1 or 2. */ + 'NAV_SOUND:index': { + name: 'NAV SOUND:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Nav standby frequency. Index is 1 or 2. */ + 'NAV_STANDBY_FREQUENCY:index': { + name: 'NAV STANDBY FREQUENCY:index', + units: 'MHz', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns whether the Nav is going to or from the current radial (or is off). */ + NAV_TOFROM: { + name: 'NAV TOFROM', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The volume of the Nav radio. */ + NAV_VOLUME: { + name: 'NAV VOLUME', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Distance of the VOR beacon. */ + NAV_VOR_DISTANCE: { + name: 'NAV VOR DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the VOR station latitude, longitude and altitude. */ + 'NAV_VOR_LATLONALT:index': { + name: 'NAV VOR LATLONALT:index', + units: 'SIMCONNECT_DATA_LATLONALT structure', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** Nav VOR latitude, longitude, altitude. */ + NAV_VOR_LLAF64: { + name: 'NAV VOR LLAF64', + units: 'SIMCONNECT_DATA_LATLONALT structure', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** The active channel used by the indexed Tacan receiver on the aircraft, from 1 to 127. */ + 'TACAN_ACTIVE_CHANNEL:index': { + name: 'TACAN ACTIVE CHANNEL:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The active mode used by the indexed Tacan receiver on the aircraft, where 0 = X and 1 = Y. */ + 'TACAN_ACTIVE_MODE:index': { + name: 'TACAN ACTIVE MODE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Will be TRUE (1) if NAV1, NAV2, NAV3 or NAV4 can receive Tacan (depending on the index - 1, 2, 3, or 4), or FALSE (0) otherwise. */ + 'TACAN_AVAILABLE:index': { + name: 'TACAN AVAILABLE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Tells whether the Tacan is driving the +Nav 1 indicator (TRUE, 1) or not (FALSE, 0), for autopilot purposes. */ + 'TACAN_DRIVES_NAV1:index': { + name: 'TACAN DRIVES NAV1:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The Tacan OBS setting, in degrees. */ + 'TACAN_OBS:index': { + name: 'TACAN OBS:index', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The standby channel used by the indexed Tacan receiver on the aircraft, from 1 to 127. */ + 'TACAN_STANDBY_CHANNEL:index': { + name: 'TACAN STANDBY CHANNEL:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Indicates +the indexed Tacan receiver standby mode, where 0 = X and 1 = Y. */ + 'TACAN_STANDBY_MODE:index': { + name: 'TACAN STANDBY MODE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The CDI needle deflection amount(course deviation) to the station. Can be +/- 127. */ + 'TACAN_STATION_CDI:index': { + name: 'TACAN STATION CDI:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The distance between the Tacan station position and the aircraft position. The index value refers to the Tacan receiver connected to the station (1 or 2). */ + 'TACAN_STATION_DISTANCE:index': { + name: 'TACAN STATION DISTANCE:index', + units: 'Meter', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The tuned station identifier for the indexed Tacan. */ + 'TACAN_STATION_IDENT:index': { + name: 'TACAN STATION IDENT:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Retrieves the latitude, longitude and altitude of the Tacan station. */ + 'TACAN_STATION_LATLONALT:index': { + name: 'TACAN STATION LATLONALT:index', + units: 'SIMCONNECT_DATA_LATLONALT', + dataType: SimConnectDataType.LATLONALT, + settable: false, + }, + /** The radial between the Tacan station and the aircraft. */ + 'TACAN_STATION_RADIAL:index': { + name: 'TACAN STATION RADIAL:index', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Difference between the current radial and OBS tuned radial, in degrees. */ + 'TACAN_STATION_RADIAL_ERROR:index': { + name: 'TACAN STATION RADIAL ERROR:index', + units: 'Degrees.', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns whether the indexed Tacan is going to or from the current radial (or is off). */ + 'TACAN_STATION_TOFROM:index': { + name: 'TACAN STATION TOFROM:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The volume value of the indexed Tacan receiver on the aircraft. */ + 'TACAN_VOLUME:index': { + name: 'TACAN VOLUME:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** On which channel the copilot is transmitting. */ + COPILOT_TRANSMITTER_TYPE: { + name: 'COPILOT TRANSMITTER TYPE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the copilot is transmitting. */ + COPILOT_TRANSMITTING: { + name: 'COPILOT TRANSMITTING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** On which channel the pilot is transmitting. */ + PILOT_TRANSMITTER_TYPE: { + name: 'PILOT TRANSMITTER TYPE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the pilot is transmitting. */ + PILOT_TRANSMITTING: { + name: 'PILOT TRANSMITTING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Currently not used within the simulation. */ + RADIOS_AVAILABLE: { + name: 'RADIOS AVAILABLE', + units: '-', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Radar altitude. */ + RADIO_HEIGHT: { + name: 'RADIO HEIGHT', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if a transponder is available. */ + TRANSPONDER_AVAILABLE: { + name: 'TRANSPONDER AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** 4-digit code. */ + 'TRANSPONDER_CODE:index': { + name: 'TRANSPONDER CODE:index', + units: 'BCD16', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This can set the Ident transponder using the KEY_XPNDR_IDENT_SET, KEY_XPNDR_IDENT_TOGGLE, KEY_XPNDR_IDENT_ON or KEY_XPNDR_IDENT_OFF Event IDs (see XPNDR (Transponder) section for more information). When set to true, it will automatically turn false after 18 seconds. */ + TRANSPONDER_IDENT: { + name: 'TRANSPONDER IDENT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Transponder State. */ + TRANSPONDER_STATE: { + name: 'TRANSPONDER STATE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Angle of True calibration scale on airspeed indicator. */ + AIRSPEED_TRUE_CALIBRATE: { + name: 'AIRSPEED TRUE CALIBRATE', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Alternate static air source. */ + 'ALTERNATE_STATIC_SOURCE_OPEN:index': { + name: 'ALTERNATE STATIC SOURCE OPEN:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Anemometer rpm as a percentage. */ + ANEMOMETER_PCT_RPM: { + name: 'ANEMOMETER PCT RPM', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** AoA indication. */ + ANGLE_OF_ATTACK_INDICATOR: { + name: 'ANGLE OF ATTACK INDICATOR', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Currently not used in the simulation. */ + ANNUNCIATOR_SWITCH: { + name: 'ANNUNCIATOR SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Used when too close to a fire. */ + APPLY_HEAT_TO_SYSTEMS: { + name: 'APPLY HEAT TO SYSTEMS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** True if the audio panel is available. */ + AUDIO_PANEL_AVAILABLE: { + name: 'AUDIO PANEL AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The Volume of the Audio Panel. */ + AUDIO_PANEL_VOLUME: { + name: 'AUDIO PANEL VOLUME', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Auto-throttle active. */ + AUTOTHROTTLE_ACTIVE: { + name: 'AUTOTHROTTLE ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is auto-coordination active. */ + AUTO_COORDINATION: { + name: 'AUTO COORDINATION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The avionics master switch position, true if the switch is ON. Use an avionics circuit index when referencing. */ + 'AVIONICS_MASTER_SWITCH:index': { + name: 'AVIONICS MASTER SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the No Smoking switch is on. */ + CABIN_NO_SMOKING_ALERT_SWITCH: { + name: 'CABIN NO SMOKING ALERT SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the Seatbelts switch is on. */ + CABIN_SEATBELTS_ALERT_SWITCH: { + name: 'CABIN SEATBELTS ALERT SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent primary door/exit open. */ + CANOPY_OPEN: { + name: 'CANOPY OPEN', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if carburetor +heat available. */ + CARB_HEAT_AVAILABLE: { + name: 'CARB HEAT AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Rate of turn of heading indicator. */ + DELTA_HEADING_RATE: { + name: 'DELTA HEADING RATE', + units: 'Radians per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** DME audio flag. */ + DME_SOUND: { + name: 'DME SOUND', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the Emergency Locator Transmitter is active. */ + ELT_ACTIVATED: { + name: 'ELT ACTIVATED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Generic SimVar. */ + EXTERNAL_SYSTEM_VALUE: { + name: 'EXTERNAL SYSTEM VALUE', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if the fire bottle is discharged. */ + FIRE_BOTTLE_DISCHARGED: { + name: 'FIRE BOTTLE DISCHARGED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the fire bottle switch is on. */ + FIRE_BOTTLE_SWITCH: { + name: 'FIRE BOTTLE SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This variable will return a value between 0 and 1 for the automatic brightness setting for glass cockpit displays, where 0 is the dimmest and 1 is the brightest. This value will vary depending on the time of day. */ + GLASSCOCKPIT_AUTOMATIC_BRIGHTNESS: { + name: 'GLASSCOCKPIT AUTOMATIC BRIGHTNESS', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the Ground Proximity Warning System is active. */ + GPWS_SYSTEM_ACTIVE: { + name: 'GPWS SYSTEM ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** True if Ground Proximity Warning System installed. */ + GPWS_WARNING: { + name: 'GPWS WARNING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Angular error of heading indicator. */ + GYRO_DRIFT_ERROR: { + name: 'GYRO DRIFT ERROR', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Will return whether the aircraft has stall protection (true) or not (false). */ + HAS_STALL_PROTECTION: { + name: 'HAS STALL PROTECTION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Heading indicator (directional gyro) indication. */ + HEADING_INDICATOR: { + name: 'HEADING INDICATOR', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indicated altitude. */ + INDICATED_ALTITUDE: { + name: 'INDICATED ALTITUDE', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Indicated altitude with the altimeter calibrated to current sea level pressure. */ + INDICATED_ALTITUDE_CALIBRATED: { + name: 'INDICATED ALTITUDE CALIBRATED', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Similar to INDICATED_ALTITUDE but doesn't affect actual plane position when setting this variable. */ + INDICATED_ALTITUDE_EX1: { + name: 'INDICATED ALTITUDE EX1', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Inductor compass heading. */ + INDUCTOR_COMPASS_HEADING_REF: { + name: 'INDUCTOR COMPASS HEADING REF', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Inductor compass deviation reading. */ + INDUCTOR_COMPASS_PERCENT_DEVIATION: { + name: 'INDUCTOR COMPASS PERCENT DEVIATION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, do not use! */ + INSTRUMENTS_AVAILABLE: { + name: 'INSTRUMENTS AVAILABLE', + units: 'Mask', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Intercom Mode */ + INTERCOM_MODE: { + name: 'INTERCOM MODE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether or not the intercom system is active. */ + INTERCOM_SYSTEM_ACTIVE: { + name: 'INTERCOM SYSTEM ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the altitude of the aircraft is frozen. */ + IS_ALTITUDE_FREEZE_ON: { + name: 'IS ALTITUDE FREEZE ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the attitude (pitch, bank and heading) of the aircraft is frozen. */ + IS_ATTITUDE_FREEZE_ON: { + name: 'IS ATTITUDE FREEZE ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the lat/lon of the aircraft (either user or AI controlled) is frozen. If this variable returns true, it means that the latitude and longitude of the aircraft are not being controlled by ESP, so enabling, for example, a SimConnect client to control the position of the aircraft. This can also apply to altitude and attitude. + + Also refer to the range of KEY_FREEZE..... Event IDs. */ + IS_LATITUDE_LONGITUDE_FREEZE_ON: { + name: 'IS LATITUDE LONGITUDE FREEZE ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The value for the given altimeter index in inches of mercury. + IMPORTANT! In the system.cfg file, altimeters are indexed from 0, but the SimVar indexes from 1. So, altimeter 0 in that file is accessed using KOHLSMAN SETTING HG:1, 1 by KOHLSMAN SETTING HG:2, etc... */ + 'KOHLSMAN_SETTING_HG:index': { + name: 'KOHLSMAN SETTING HG:index', + units: 'Inches of Mercury, inHg', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The value for the given altimeter index in millibars. + IMPORTANT! In the system.cfg file, altimeters are indexed from 0, but the SimVar indexes from 1. So, altimeter 0 in that file is accessed using KOHLSMAN SETTING MB:1, 1 by KOHLSMAN SETTING MB:2, etc... */ + 'KOHLSMAN_SETTING_MB:index': { + name: 'KOHLSMAN SETTING MB:index', + units: 'Millibars', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the indexed altimeter is in "Standard" mode, or false otherwise. + IMPORTANT! In the system.cfg file, altimeters are indexed from 0, but the SimVar indexes from 1. So, altimeter 0 in that file is accessed using KOHLSMAN SETTING STD:1, 1 by KOHLSMAN SETTING STD:2, etc... */ + 'KOHLSMAN_SETTING_STD:index': { + name: 'KOHLSMAN SETTING STD:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Compass reading. */ + MAGNETIC_COMPASS: { + name: 'MAGNETIC COMPASS', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Position of manual fuel pump handle. 1 is fully deployed. */ + MANUAL_FUEL_PUMP_HANDLE: { + name: 'MANUAL FUEL PUMP HANDLE', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Overspeed warning state. */ + OVERSPEED_WARNING: { + name: 'OVERSPEED WARNING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if panel anti-ice switch is on. */ + PANEL_ANTI_ICE_SWITCH: { + name: 'PANEL ANTI ICE SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Amount of pitot ice. 100 is fully iced. */ + PITOT_ICE_PCT: { + name: 'PITOT ICE PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Pitot heat active. */ + PITOT_HEAT: { + name: 'PITOT HEAT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Pitot heat switch state. */ + 'PITOT_HEAT_SWITCH:index': { + name: 'PITOT HEAT SWITCH:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Standard Altitude, ie: at a 1013.25 hPa (1 atmosphere) setting. */ + PRESSURE_ALTITUDE: { + name: 'PRESSURE ALTITUDE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current altitude of the cabin pressurization. */ + PRESSURIZATION_CABIN_ALTITUDE: { + name: 'PRESSURIZATION CABIN ALTITUDE', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The set altitude of the cabin pressurization as initialised from the Design Cabin Pressure value in the systems.cfg file. Pressure is converted into an altitude using a standard condition table. + You can adjust the goal pressure using the +PRESSURIZATION_PRESSURE_ALT_INC and +PRESSURIZATION_PRESSURE_ALT_DEC events. */ + PRESSURIZATION_CABIN_ALTITUDE_GOAL: { + name: 'PRESSURIZATION CABIN ALTITUDE GOAL', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The rate at which cabin pressurization changes. */ + PRESSURIZATION_CABIN_ALTITUDE_RATE: { + name: 'PRESSURIZATION CABIN ALTITUDE RATE', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the cabin pressurization dump switch is on. */ + PRESSURIZATION_DUMP_SWITCH: { + name: 'PRESSURIZATION DUMP SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The difference in pressure between the set altitude pressurization and the current pressurization. */ + PRESSURIZATION_PRESSURE_DIFFERENTIAL: { + name: 'PRESSURIZATION PRESSURE DIFFERENTIAL', + units: 'Pounds per square foot, psf', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if Rad INS switch on. */ + RAD_INS_SWITCH: { + name: 'RAD INS SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Selected DME. */ + SELECTED_DME: { + name: 'SELECTED DME', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Smoke system available. + NOTE: There is no default "smoke system" that this SimVar works on and this is a legacy variable that is available for use should you wish to use it but it affects nothing by default. */ + SMOKESYSTEM_AVAILABLE: { + name: 'SMOKESYSTEM AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Set to True to activate the smoke system, if one is available. Please see the notes for SMOKESYSTEM AVAILABLE for more information. */ + SMOKE_ENABLE: { + name: 'SMOKE ENABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Whether or not the speaker is active. */ + SPEAKER_ACTIVE: { + name: 'SPEAKER ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if stall alarm available. */ + STALL_HORN_AVAILABLE: { + name: 'STALL HORN AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Alpha below which the Stall Protection can be disabled. See the [STALL PROTECTION] section for more information. */ + STALL_PROTECTION_OFF_LIMIT: { + name: 'STALL PROTECTION OFF LIMIT', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The alpha that the Stall Protection will attempt to reach when triggered. See the [STALL PROTECTION] section for more information. */ + STALL_PROTECTION_ON_GOAL: { + name: 'STALL PROTECTION ON GOAL', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Alpha above which the Stall Protection timer starts. See the [STALL PROTECTION] section for more information. */ + STALL_PROTECTION_ON_LIMIT: { + name: 'STALL PROTECTION ON LIMIT', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Stall warning state. */ + STALL_WARNING: { + name: 'STALL WARNING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the aircraft structure deice switch is on. */ + STRUCTURAL_DEICE_SWITCH: { + name: 'STRUCTURAL DEICE SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Vacuum system suction pressure. */ + SUCTION_PRESSURE: { + name: 'SUCTION PRESSURE', + units: 'Inches of Mercury, inHg', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Deprecated, do not use! */ + SYSTEMS_AVAILABLE: { + name: 'SYSTEMS AVAILABLE', + units: 'Mask', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the tailhook handle is engaged. */ + TAILHOOK_HANDLE: { + name: 'TAILHOOK HANDLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent tail hook extended. */ + TAILHOOK_POSITION: { + name: 'TAILHOOK POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Position of tow release handle. 100 is fully deployed. */ + TOW_RELEASE_HANDLE: { + name: 'TOW RELEASE HANDLE', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if True Airspeed has been selected. */ + TRUE_AIRSPEED_SELECTED: { + name: 'TRUE AIRSPEED SELECTED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Turn coordinator ball position. */ + TURN_COORDINATOR_BALL: { + name: 'TURN COORDINATOR BALL', + units: 'Position 128', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Turn coordinator ball position inverted (upside down). */ + TURN_COORDINATOR_BALL_INV: { + name: 'TURN COORDINATOR BALL INV', + units: 'Position 128', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Turn indicator reading. + NOTE: This is available in multiplayer to all +near +aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + TURN_INDICATOR_RATE: { + name: 'TURN INDICATOR RATE', + units: 'Radians per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if turn indicator switch is on. */ + TURN_INDICATOR_SWITCH: { + name: 'TURN INDICATOR SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if the aircraft windshield deice switch is on. */ + WINDSHIELD_DEICE_SWITCH: { + name: 'WINDSHIELD DEICE SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Deprecated, do not use! + Use MAGNETIC_COMPASS instead. */ + WISKEY_COMPASS_INDICATION_DEGREES: { + name: 'WISKEY COMPASS INDICATION DEGREES', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The MacCready setting used to fly an optimal speed between thermals. */ + VARIOMETER_MAC_CREADY_SETTING: { + name: 'VARIOMETER MAC CREADY SETTING', + units: 'Meters per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Variometer rate using Netto (Total Energy - polar sinkRate). */ + VARIOMETER_NETTO: { + name: 'VARIOMETER NETTO', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The variometer rate. */ + VARIOMETER_RATE: { + name: 'VARIOMETER RATE', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Optimal speed to fly between thermals using polar curve and MacCready setting. */ + VARIOMETER_SPEED_TO_FLY: { + name: 'VARIOMETER SPEED TO FLY', + units: 'Kilometers per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The glide ratio at optimal speed to fly. */ + VARIOMETER_SPEED_TO_FLY_GLIDE_RATIO: { + name: 'VARIOMETER SPEED TO FLY GLIDE RATIO', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the variometer switch is on, false if it is not. */ + VARIOMETER_SWITCH: { + name: 'VARIOMETER SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The variometer rate using total energy. + Total Energy = Potential Energy + Kinetic Energy */ + VARIOMETER_TOTAL_ENERGY: { + name: 'VARIOMETER TOTAL ENERGY', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The capacity of the indexed water ballast tank. */ + 'WATER_BALLAST_TANK_CAPACITY:index': { + name: 'WATER BALLAST TANK CAPACITY:index', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The number of water ballast tank available. */ + WATER_BALLAST_TANK_NUMBER: { + name: 'WATER BALLAST TANK NUMBER', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The quantity of water ballast in the indexed tank. */ + 'WATER_BALLAST_TANK_QUANTITY:index': { + name: 'WATER BALLAST TANK QUANTITY:index', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True (1) if a water ballast valve is available, False (0) otherwise. */ + WATER_BALLAST_VALVE: { + name: 'WATER BALLAST VALVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The flow rate of the water ballast valve. */ + WATER_BALLAST_VALVE_FLOW_RATE: { + name: 'WATER BALLAST VALVE FLOW RATE', + units: 'Gallons per hour', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This variable will return 1 (TRUE) if all the ballast tank valves are open, or 0 (FALSE) otherwise. */ + WATER_BALLAST_EVERY_VALVE_OPEN: { + name: 'WATER BALLAST EVERY VALVE OPEN', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Will return true if any interior light is on or false otherwise. */ + IS_ANY_INTERIOR_LIGHT_ON: { + name: 'IS ANY INTERIOR LIGHT ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Landing light pitch bank and heading. */ + LANDING_LIGHT_PBH: { + name: 'LANDING LIGHT PBH', + units: 'SIMCONNECT_DATA_XYZ structure', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** Light switch state. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_BEACON: { + name: 'LIGHT BEACON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target beacon light is functioning or if the switch is ON. Use beacon lightdef index. */ + LIGHT_BEACON_ON: { + name: 'LIGHT BEACON ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Vehicle backlights current intensity (0 = off, 1 = full intensity). */ + LIGHT_BACKLIGHT_INTENSITY: { + name: 'LIGHT BACKLIGHT INTENSITY', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns true if the target brake light is functioning or if the switch is ON. */ + LIGHT_BRAKE_ON: { + name: 'LIGHT BRAKE ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Light switch state. */ + LIGHT_CABIN: { + name: 'LIGHT CABIN', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target cabin light is functioning or if the switch is ON. Use the cabin lightdef index. */ + LIGHT_CABIN_ON: { + name: 'LIGHT CABIN ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The current cabin light power setting. Requires the cabin lightdef index. */ + LIGHT_CABIN_POWER_SETTING: { + name: 'LIGHT CABIN POWER SETTING', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether or not the Light switch for the Glareshield is enabled. */ + LIGHT_GLARESHIELD: { + name: 'LIGHT GLARESHIELD', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target glareshield light is functioning or if the switch is ON. Use the glareshield lightdef index. */ + LIGHT_GLARESHIELD_ON: { + name: 'LIGHT GLARESHIELD ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The current glareshield light power setting. Requires the glareshield lightdef index. */ + LIGHT_GLARESHIELD_POWER_SETTING: { + name: 'LIGHT GLARESHIELD POWER SETTING', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Vehicle gyrolights current intensity (0 = off, 1 = full intensity). */ + LIGHT_GYROLIGHT_INTENSITY: { + name: 'LIGHT GYROLIGHT INTENSITY', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns true if the target navigation light is functioning or if the switch is ON. */ + LIGHT_HEAD_ON: { + name: 'LIGHT HEAD ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Vehicle headlights current intensity (0 = off, 1 = full intensity). */ + LIGHT_HEADLIGHT_INTENSITY: { + name: 'LIGHT HEADLIGHT INTENSITY', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Returns true if the target landing light is functioning or if the switch is ON. Use landing lightdef index. */ + LIGHT_LANDING_ON: { + name: 'LIGHT LANDING ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Light switch state for landing light. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_LANDING: { + name: 'LIGHT LANDING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Light switch state for logo light. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_LOGO: { + name: 'LIGHT LOGO', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target logo light is functioning or if the switch is ON. Use the logo lightdef index. */ + LIGHT_LOGO_ON: { + name: 'LIGHT LOGO ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns true if the target navigation light is functioning or if the switch is ON. Use navigation lightdef index. */ + LIGHT_NAV_ON: { + name: 'LIGHT NAV ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Light switch state for the NAV light. */ + LIGHT_NAV: { + name: 'LIGHT NAV', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Bit mask:[index] + + 0x0001:[index] Nav + 0x0002:[index] Beacon + 0x0004:[index] Landing + 0x0008:[index] Taxi + 0x0010:[index] Strobe + 0x0020:[index] Panel + 0x0040:[index] Recognition + 0x0080:[index] Wing + 0x0100:[index] Logo + 0x0200:[index] Cabin */ + LIGHT_ON_STATES: { + name: 'LIGHT ON STATES', + units: 'Mask', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Light switch state of the panel light. */ + LIGHT_PANEL: { + name: 'LIGHT PANEL', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target panel light is functioning or if the switch is ON. Use the panel lightdef index. */ + LIGHT_PANEL_ON: { + name: 'LIGHT PANEL ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The current panel light power setting. Requires the panel lightdef index. */ + LIGHT_PANEL_POWER_SETTING: { + name: 'LIGHT PANEL POWER SETTING', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether or not the Light switch for the Pedestal is enabled. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_PEDESTRAL: { + name: 'LIGHT PEDESTRAL', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target pedestral light is functioning or if the switch is ON. Requires the pedestral lightdef index. */ + LIGHT_PEDESTRAL_ON: { + name: 'LIGHT PEDESTRAL ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The current pedestral light power setting. Requires the pedestral lightdef index. */ + LIGHT_PEDESTRAL_POWER_SETTING: { + name: 'LIGHT PEDESTRAL POWER SETTING', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Adjust the potentiometer of the indexed lighting. Index is defined in the appropriate lightdef hashmap setting. */ + 'LIGHT_POTENTIOMETER:index': { + name: 'LIGHT POTENTIOMETER:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Light switch state for the recognition light. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_RECOGNITION: { + name: 'LIGHT RECOGNITION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target recognition light is functioning or if the switch is ON. Use the recognition lightdef index. */ + LIGHT_RECOGNITION_ON: { + name: 'LIGHT RECOGNITION ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Same as LIGHT_ON_STATES. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_STATES: { + name: 'LIGHT STATES', + units: 'Mask', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Light switch state for the strobe lights. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_STROBE: { + name: 'LIGHT STROBE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target strobe light is functioning or if the switch is ON. Use the strobe lightdef index. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_STROBE_ON: { + name: 'LIGHT STROBE ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Light switch state for the taxi light. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_TAXI: { + name: 'LIGHT TAXI', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target taxi light is functioning or if the switch is ON. Use taxi lightdef index. */ + LIGHT_TAXI_ON: { + name: 'LIGHT TAXI ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Light switch state for the wing lights. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + LIGHT_WING: { + name: 'LIGHT WING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if the target wing light is functioning or if the switch is ON. Use the wing lightdef index. */ + LIGHT_WING_ON: { + name: 'LIGHT WING ON', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if instrument lights are set manually. */ + MANUAL_INSTRUMENT_LIGHTS: { + name: 'MANUAL INSTRUMENT LIGHTS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True if strobe lights are available. */ + STROBES_AVAILABLE: { + name: 'STROBES AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Deprecated, do not use! */ + STROBE_FLASH: { + name: 'STROBE FLASH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Hydraulic system pressure. Indexes start at 1. */ + 'HYDRAULIC_PRESSURE:index': { + name: 'HYDRAULIC PRESSURE:index', + units: 'Pound force per square foot', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Hydraulic pressure changes will follow changes to this variable. Indexes start at 1. */ + 'HYDRAULIC_RESERVOIR_PERCENT:index': { + name: 'HYDRAULIC RESERVOIR PERCENT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True if hydraulic switch is on. */ + HYDRAULIC_SWITCH: { + name: 'HYDRAULIC SWITCH', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Percent system functional. */ + HYDRAULIC_SYSTEM_INTEGRITY: { + name: 'HYDRAULIC SYSTEM INTEGRITY', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_ADF: { + name: 'PARTIAL PANEL ADF', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_AIRSPEED: { + name: 'PARTIAL PANEL AIRSPEED', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_ALTIMETER: { + name: 'PARTIAL PANEL ALTIMETER', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_ATTITUDE: { + name: 'PARTIAL PANEL ATTITUDE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_AVIONICS: { + name: 'PARTIAL PANEL AVIONICS', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_COMM: { + name: 'PARTIAL PANEL COMM', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_COMPASS: { + name: 'PARTIAL PANEL COMPASS', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_ELECTRICAL: { + name: 'PARTIAL PANEL ELECTRICAL', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_ENGINE: { + name: 'PARTIAL PANEL ENGINE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_FUEL_INDICATOR: { + name: 'PARTIAL PANEL FUEL INDICATOR', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_HEADING: { + name: 'PARTIAL PANEL HEADING', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_NAV: { + name: 'PARTIAL PANEL NAV', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_PITOT: { + name: 'PARTIAL PANEL PITOT', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_TRANSPONDER: { + name: 'PARTIAL PANEL TRANSPONDER', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_TURN_COORDINATOR: { + name: 'PARTIAL PANEL TURN COORDINATOR', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_VACUUM: { + name: 'PARTIAL PANEL VACUUM', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gauge fail flag. */ + PARTIAL_PANEL_VERTICAL_VELOCITY: { + name: 'PARTIAL PANEL VERTICAL VELOCITY', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The number of droppable objects at the station number identified by the index. */ + 'DROPPABLE_OBJECTS_COUNT:index': { + name: 'DROPPABLE OBJECTS COUNT:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The type of droppable object at the station number identified by the index. */ + 'DROPPABLE_OBJECTS_TYPE:index': { + name: 'DROPPABLE OBJECTS TYPE:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: true, + }, + /** Descriptive name, used in User Interface dialogs, of a droppable object, identified by index. */ + 'DROPPABLE_OBJECTS_UI_NAME:index': { + name: 'DROPPABLE OBJECTS UI NAME:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Number of payload stations (1 to 15). */ + PAYLOAD_STATION_COUNT: { + name: 'PAYLOAD STATION COUNT', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Descriptive name for payload station. */ + 'PAYLOAD_STATION_NAME:index': { + name: 'PAYLOAD STATION NAME:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The number of objects at the payload station. */ + 'PAYLOAD_STATION_NUM_SIMOBJECTS:index': { + name: 'PAYLOAD STATION NUM SIMOBJECTS:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Places the named object at the payload station identified by the index (starting from 1). The string is the Container name (refer to the title property of Simulation Object Configuration Files). */ + 'PAYLOAD_STATION_OBJECT:index': { + name: 'PAYLOAD STATION OBJECT:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Individual payload station weight. */ + 'PAYLOAD_STATION_WEIGHT:index': { + name: 'PAYLOAD STATION WEIGHT:index', + units: 'Pounds', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This is the current state of the fuel warning, either on (true) or off (false). */ + WARNING_FUEL: { + name: 'WARNING FUEL', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is the current state of the left fuel tank warning, either on (true) or off (false). */ + WARNING_FUEL_LEFT: { + name: 'WARNING FUEL LEFT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is the current state of the right fuel tank warning, either on (true) or off (false). */ + WARNING_FUEL_RIGHT: { + name: 'WARNING FUEL RIGHT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is the current state of the low height warning, either on (true) or off (false). */ + WARNING_LOW_HEIGHT: { + name: 'WARNING LOW HEIGHT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is the current state of the oil pressure warning, either on (true) or off (false). */ + WARNING_OIL_PRESSURE: { + name: 'WARNING OIL PRESSURE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is the current state of the vacuum system warning, either on (true) or off (false). */ + WARNING_VACUUM: { + name: 'WARNING VACUUM', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is the current state of the left vacuum system warning, either on (true) or off (false). */ + WARNING_VACUUM_LEFT: { + name: 'WARNING VACUUM LEFT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is the current state of the right vacuum system warning, either on (true) or off (false). */ + WARNING_VACUUM_RIGHT: { + name: 'WARNING VACUUM RIGHT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is the current state of the electrical system voltage warning, either on (true) or off (false). */ + WARNING_VOLTAGE: { + name: 'WARNING VOLTAGE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Yoke position in horizontal direction. */ + YOKE_X_INIDICATOR: { + name: 'YOKE X INIDICATOR', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent control deflection left/right (for animation). */ + YOKE_X_POSITION: { + name: 'YOKE X POSITION', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent control deflection left/right (for animation). Also includes AP's inputs. */ + YOKE_X_POSITION_WITH_AP: { + name: 'YOKE X POSITION WITH AP', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Yoke position in vertical direction. */ + YOKE_Y_INIDICATOR: { + name: 'YOKE Y INIDICATOR', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent control deflection fore/aft (for animation). */ + YOKE_Y_POSITION: { + name: 'YOKE Y POSITION', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Percent control deflection fore/aft (for animation). Also includes AP's inputs. */ + YOKE_Y_POSITION_WITH_AP: { + name: 'YOKE Y POSITION WITH AP', + units: 'Position', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent door/exit open. */ + 'EXIT_OPEN:index': { + name: 'EXIT OPEN:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Position of exit relative to datum reference point. */ + 'EXIT_POSX:index': { + name: 'EXIT POSX:index', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Position of exit relative to datum reference point. */ + 'EXIT_POSY:index': { + name: 'EXIT POSY:index', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Position of exit relative to datum reference point. */ + 'EXIT_POSZ:index': { + name: 'EXIT POSZ:index', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The exit type. */ + 'EXIT_TYPE:index': { + name: 'EXIT TYPE:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The position of the helicopter\'s collective. 0 is fully up, 100 fully depressed. */ + COLLECTIVE_POSITION: { + name: 'COLLECTIVE POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Rotor bank angle of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'DISK_BANK_ANGLE:index': { + name: 'DISK BANK ANGLE:index', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Rotor bank percent of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'DISK_BANK_PCT:index': { + name: 'DISK BANK PCT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Rotor coning percent of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'DISK_CONING_PCT:index': { + name: 'DISK CONING PCT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Rotor pitch angle of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'DISK_PITCH_ANGLE:index': { + name: 'DISK PITCH ANGLE:index', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Rotor pitch percent of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'DISK_PITCH_PCT:index': { + name: 'DISK PITCH PCT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether the rotor brake is active (1, TRUE) or not (0, FALSE). */ + ROTOR_BRAKE_ACTIVE: { + name: 'ROTOR BRAKE ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The percentage actuated of the rotor brake handle. */ + ROTOR_BRAKE_HANDLE_POS: { + name: 'ROTOR BRAKE HANDLE POS', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether the rotor chip is detected (1,TRUE) or not (0, FALSE). */ + ROTOR_CHIP_DETECTED: { + name: 'ROTOR CHIP DETECTED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Whether the rotor clutch is active (1, TRUE) or not (0, FALSE). */ + ROTOR_CLUTCH_ACTIVE: { + name: 'ROTOR CLUTCH ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The rotor clutch switch position, either on (1 TRUE) or off (0, FALSE). */ + ROTOR_CLUTCH_SWITCH_POS: { + name: 'ROTOR CLUTCH SWITCH POS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The rotor collective blade pitch. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + ROTOR_COLLECTIVE_BLADE_PITCH_PCT: { + name: 'ROTOR COLLECTIVE BLADE PITCH PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The position (angle) at which blade has the maximum cyclic pitch. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + ROTOR_CYCLIC_BLADE_MAX_PITCH_POSITION: { + name: 'ROTOR CYCLIC BLADE MAX PITCH POSITION', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The rotor cyclic blade (maximum) pitch. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + ROTOR_CYCLIC_BLADE_PITCH_PCT: { + name: 'ROTOR CYCLIC BLADE PITCH PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Whether the rotor governor is active (1, TRUE) or not (0, FALSE). */ + ROTOR_GOV_ACTIVE: { + name: 'ROTOR GOV ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The rotor governor switch position, either on (1 TRUE) or off (0, FALSE). */ + ROTOR_GOV_SWITCH_POS: { + name: 'ROTOR GOV SWITCH POS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The rotor lateral trim percentage. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + ROTOR_LATERAL_TRIM_PCT: { + name: 'ROTOR LATERAL TRIM PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The rotor longitudinal trim percentage. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + ROTOR_LONGITUDINAL_TRIM_PCT: { + name: 'ROTOR LONGITUDINAL TRIM PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Rotor rotation angle of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'ROTOR_ROTATION_ANGLE:index': { + name: 'ROTOR ROTATION ANGLE:index', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The indexed rotor +RPM. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'ROTOR_RPM:index': { + name: 'ROTOR RPM:index', + units: 'RPM', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent max rated rpm of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. */ + 'ROTOR_RPM_PCT:index': { + name: 'ROTOR RPM PCT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The main rotor transmission temperature. */ + ROTOR_TEMPERATURE: { + name: 'ROTOR TEMPERATURE', + units: 'Rankine', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The position of the indexed rotor. */ + 'STRUCT_ROTOR_POSITION:index': { + name: 'STRUCT ROTOR POSITION:index', + units: 'SIMCONNECT_DATA_XYZ', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** The pitch position of the tailrotor blades. */ + TAIL_ROTOR_BLADE_PITCH_PCT: { + name: 'TAIL ROTOR BLADE PITCH PCT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Percent tail rotor pedal deflection. */ + TAIL_ROTOR_PEDAL_POSITION: { + name: 'TAIL ROTOR PEDAL POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the indexed rotor +RPM. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + 'ENG_ROTOR_RPM:index': { + name: 'ENG ROTOR RPM:index', + units: 'Percent scalar 16K (Max rpm * 16384)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the indexed rotor torque. */ + 'ENG_TORQUE_PERCENT:index': { + name: 'ENG TORQUE PERCENT:index', + units: 'Percent scalar 16K (Ft/lbs * 16384)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the position of the master throttle as a value between 0 and 1. */ + HELICOPTER_MASTER_THROTTLE_POSITION: { + name: 'HELICOPTER_MASTER_THROTTLE_POSITION', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Set to true if this object is attached to a sling. */ + IS_ATTACHED_TO_SLING: { + name: 'IS ATTACHED TO SLING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The number of sling cables (not hoists) that are configured for the helicopter. */ + NUM_SLING_CABLES: { + name: 'NUM SLING CABLES', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The payload station (identified by the parameter) where objects will be placed from the sling (identified by the index). */ + 'SLING_ACTIVE_PAYLOAD_STATION:index,_param': { + name: 'SLING ACTIVE PAYLOAD STATION:index, param', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** THis will be True (1) if the indexed cable is broken, or False (0) otherwise. */ + 'SLING_CABLE_BROKEN:index': { + name: 'SLING CABLE BROKEN:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The length of the indexed cable extending from the aircraft. */ + 'SLING_CABLE_EXTENDED_LENGTH:index': { + name: 'SLING CABLE EXTENDED LENGTH:index', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The percentage of the full length of the sling cable deployed. */ + 'SLING_HOIST_PERCENT_DEPLOYED:index': { + name: 'SLING HOIST PERCENT DEPLOYED:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This will be True (1) if the hoist is enabled or False (0) otherwise. */ + 'SLING_HOIST_SWITCH:index': { + name: 'SLING HOIST SWITCH:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This will be True (1) if the hook is in pickup mode or False (0) otherwise. When True, the hook will be capable of picking up another object. */ + SLING_HOOK_IN_PICKUP_MODE: { + name: 'SLING HOOK IN PICKUP MODE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** If the SimVar units are set as boolean, this will return True (1) if a sling object is attached, or False (0) otherwise. + If the SimVar units are set as a string, tis will return the container title of the object. + Note that there can be multiple sling positions, indexed from 1. The sling positions are set in the Aircraft Configuration File. */ + 'SLING_OBJECT_ATTACHED:index': { + name: 'SLING OBJECT ATTACHED:index', + units: 'Bool/String', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The electrical load on the indexed engine. */ + 'ENG_ELECTRICAL_LOAD:index': { + name: 'ENG ELECTRICAL LOAD:index', + units: 'Percent scalar 16K (Max load * 16384)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The fuel pressure for the indexed engine. */ + 'ENG_FUEL_PRESSURE:index': { + name: 'ENG FUEL PRESSURE:index', + units: 'PSI scalar 16K (Psi * 16384)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The transmission pressure of the indexed engine. */ + 'ENG_TRANSMISSION_PRESSURE:index': { + name: 'ENG TRANSMISSION PRESSURE:index', + units: 'PSI scalar 16K (Psi * 16384)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The transmission temperature of the indexed engine. */ + 'ENG_TRANSMISSION_TEMPERATURE:index': { + name: 'ENG TRANSMISSION TEMPERATURE:index', + units: 'Celsius scalar 16K (Degrees * 16384)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The tubine temperature for the indexed engine. */ + 'ENG_TURBINE_TEMPERATURE:index': { + name: 'ENG TURBINE TEMPERATURE:index', + units: 'Celsius scalar 16K (degrees * 16384)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns either the pitch (index 0) or the yaw (index 1) of the current gameplay camera. */ + 'CAMERA_GAMEPLAY_PITCH_YAW:index': { + name: 'CAMERA GAMEPLAY PITCH YAW:index', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** This can be used to have the currently active camera perform a predefined action. Currently only 1 action is supported, but more may be added over time. */ + CAMERA_REQUEST_ACTION: { + name: 'CAMERA REQUEST ACTION', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This can be used to get or set the camera "state", which will be one of the listed enum values. + Note that not ALL possible enum values are shown, since some values are internal only, and some values will do nothing, but have been reserved for future expansion of the camera system. + Also note that the value "9" is a special case, generally used only when working with in-sim panels and is used to go to the showcase cameras, defaulting to the last selected camera within this section (Drone, Fixed or Environment). */ + CAMERA_STATE: { + name: 'CAMERA STATE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This variable can be used to get or set the camera "sub-state". The options here are generally only required when working with the in-sim panel UI. Note that the "locked" and "unlocked" state will be changed automatically if the following SimVars have their values changed: COCKPIT_CAMERA_HEADLOOK, CHASE_CAMERA_HEADLOOK. */ + CAMERA_SUBSTATE: { + name: 'CAMERA SUBSTATE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** With this you can get or set both the type of view for the current camera, as well as the option index, which will be between 0 and the maximum index value (as retrieved using the CAMERA VIEW TYPE AND INDEX MAX SimVar). Supplying an index of 0 to the SimVar will get/set the type (from the selection of enum values listed), and using an index of 1 will get/set the option index, which is an integer value. + + + Please see the Notes On View Types And Indices section below for more information. */ + 'CAMERA_VIEW_TYPE_AND_INDEX:index': { + name: 'CAMERA VIEW TYPE AND INDEX:index', + units: 'Enum (index = 0):', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This variable can get the number of option indices related to a specific camera view type. The index value supplied to the SimVar should be one of the camera view type Enum values (see CAMERA VIEW TYPE AND INDEX), and the SimVar will return the number of options available for that camera type (counting from 1, so - for example - if the camera view type is "Quickview" and has 8 quickview settings, then CAMERA VIEW TYPE AND INDEX MAX:4 will return 8). Note that this value can be set after a flight has started, but it will have no effect since the number of camera options is initilaised once only and not updated (and the simulation may overwrite the value again even after setting it). + + + Please see the Notes On View Types And Indices section below for more information. */ + 'CAMERA_VIEW_TYPE_AND_INDEX_MAX:index': { + name: 'CAMERA VIEW TYPE AND INDEX MAX:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This gets/sets the focus for the camera zoom, which can be either manual, or auto. The setting affects both the Cockpit and the External (Chase) cameras. + The following SimVars can be used to get/set the level of zoom: COCKPIT_CAMERA_ZOOM or CHASE_CAMERA_ZOOM. */ + GAMEPLAY_CAMERA_FOCUS: { + name: 'GAMEPLAY CAMERA FOCUS', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This SimVar is used to check for a collision along a ray from the center of the user +FOV +and a model node. The available nodes that can be checked using this SimVar must be previously defined in the +[CAMERA_RAY_NODE_COLLISION] +of the cameras.cfg file. The SimVar requires a node +index +value between 1 and 10, corresponding to the node defined in the CFG file, and the SimVar will return 1 (TRUE) if there is a collision along the camera ray or 0 (FALSE) otherwise. You may also supply an index of 0 to perform a collision check for +all +defined nodes, in which case the SimVar will return 1 (TRUE) if there is a collision between the ray and +any +of the defined nodes. Supplying an index outside of the range of 1 to 10, or supplying an index for which no node has been defined, will return 0 (FALSE). */ + IS_CAMERA_RAY_INTERSECT_WITH_NODE: { + name: 'IS CAMERA RAY INTERSECT WITH NODE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This is used to get/set the look state of the chase (external) camera. Note that this value will also affect the CAMERA_SUBSTATE value, when the CAMERA_STATE is set to 3 (External/Chase). */ + CHASE_CAMERA_HEADLOOK: { + name: 'CHASE CAMERA HEADLOOK', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Sets/gets the momentum modifier of the chase (external) camera, which is controls how fast/slow the camera will stop moving when no longer being moved by the user. Default is 50%. */ + CHASE_CAMERA_MOMENTUM: { + name: 'CHASE CAMERA MOMENTUM', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the translation speed modifier of the chase (external) camara, as a percentage. Default is 50%. */ + CHASE_CAMERA_SPEED: { + name: 'CHASE CAMERA SPEED', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the zoom/FOV modifier for the chase (external) camera. Note that when setting this value, it will affect the camera regardless of whether the GAMEPLAY_CAMERA_FOCUS is set to manual or automatic. Default is 50%. */ + CHASE_CAMERA_ZOOM: { + name: 'CHASE CAMERA ZOOM', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the speed modifier for when the zoom/FOV chase (external) camera changes zoom/FOV levels. Default is 50%. */ + CHASE_CAMERA_ZOOM_SPEED: { + name: 'CHASE CAMERA ZOOM SPEED', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This can be used to reset the cockpit camera when the CAMERA_STATE is set to 2 (Cockpit). Essentially the same as the user pressing the default reset keys CTRL + Space. */ + CAMERA_ACTION_COCKPIT_VIEW_RESET: { + name: 'CAMERA ACTION COCKPIT VIEW RESET', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This can be used to save a cockpit camera when the CAMERA_STATE is set to 2 (Cockpit). The index value given is the save "slot" that will be used, from 0 to 9. Essentially this is the same as the user pressing the default save keys CTRL + Alt + 0-9. */ + 'CAMERA_ACTION_COCKPIT_VIEW_SAVE:index': { + name: 'CAMERA ACTION COCKPIT VIEW SAVE:index', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This is used to get/set the look state of the cockpit camera. Note that this value will also affect the CAMERA_SUBSTATE value, when the CAMERA_STATE is set to 2 (Cockpit). */ + COCKPIT_CAMERA_HEADLOOK: { + name: 'COCKPIT CAMERA HEADLOOK', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This can be used to get/set the cockpit camera height modifier expressed as a percentage. Default is 50%. */ + COCKPIT_CAMERA_HEIGHT: { + name: 'COCKPIT CAMERA HEIGHT', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This can be used to get or set the autoselect option for the cockpit camera when viewing the instruments (ie: the CAMERA_SUBSTATE is 5). When enabled the camera will move automatically if the player mouse reaches the edge of the screen and there are instrument panels available on that side. */ + COCKPIT_CAMERA_INSTRUMENT_AUTOSELECT: { + name: 'COCKPIT CAMERA INSTRUMENT AUTOSELECT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Sets/gets the momentum modifier of the cockpit camera, which is controls how fast/slow the camera will stop moving when no longer being moved by the user. Default is 50%. */ + COCKPIT_CAMERA_MOMENTUM: { + name: 'COCKPIT CAMERA MOMENTUM', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Not currently used in the simulation. */ + COCKPIT_CAMERA_SIDE: { + name: 'COCKPIT CAMERA SIDE', + units: 'Enum', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Sets/gets the translation speed modifier of the cockpit camara, as a percentage. Default is 50%. */ + COCKPIT_CAMERA_SPEED: { + name: 'COCKPIT CAMERA SPEED', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the current "upper position" cockpit camera toggle. When 1 (TRUE), the camera is is in the upper position, and when 0 (FALSE) it is in the default position. */ + COCKPIT_CAMERA_UPPER_POSITION: { + name: 'COCKPIT CAMERA UPPER POSITION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Sets/gets the zoom/FOV modifier for the cockpit camera. Note that when setting this value, it will affect the camera regardless of whether the GAMEPLAY_CAMERA_FOCUS is set to manual or automatic. Default is 50%. */ + COCKPIT_CAMERA_ZOOM: { + name: 'COCKPIT CAMERA ZOOM', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the speed modifier for when the zoom/FOV cockpit camera changes zoom/FOV levels. Default is 50%. */ + COCKPIT_CAMERA_ZOOM_SPEED: { + name: 'COCKPIT CAMERA ZOOM SPEED', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the focus modifier for the drone camera. Default is 50%, and a lower value will set the drone focus to things in the foreground and a higher level will set the drone focus to things in the background. Note that this is only taken into account when the DRONE_CAMERA_FOCUS_MODE is set to 3 (manual). */ + DRONE_CAMERA_FOCUS: { + name: 'DRONE CAMERA FOCUS', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the current drone focus mode. When set to 3 (manual), the focus position will be based on the DRONE_CAMERA_FOCUS value. */ + DRONE_CAMERA_FOCUS_MODE: { + name: 'DRONE CAMERA FOCUS MODE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Sets/gets the whether the drone camera is in follow mode or not. */ + DRONE_CAMERA_FOLLOW: { + name: 'DRONE CAMERA FOLLOW', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Sets/gets the zoom/FOV modifier for the drone camera. Default is 50%. */ + DRONE_CAMERA_FOV: { + name: 'DRONE CAMERA FOV', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the whether the drone camera is locked or not. */ + DRONE_CAMERA_LOCKED: { + name: 'DRONE CAMERA LOCKED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Sets/gets the rotation speed modifier of the drone camara, as a percentage. Default is 50%. */ + DRONE_CAMERA_SPEED_ROTATION: { + name: 'DRONE CAMERA SPEED ROTATION', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the translation speed modifier of the drone camara, as a percentage. Default is 50%. */ + DRONE_CAMERA_SPEED_TRAVELLING: { + name: 'DRONE CAMERA SPEED TRAVELLING', + units: 'Percentage', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Sets/gets the whether the smart camera is active or not. */ + SMART_CAMERA_ACTIVE: { + name: 'SMART CAMERA ACTIVE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Gets information on the smartcam system. The index sets what kind of information will be returned (or set): + + 0 = Gets the number of smartcam targets in the smart camera list + 1 = Gets or sets the index of the currently selected smartcam target, counting from 0 (so index 0 is the first target in the list). */ + 'SMART_CAMERA_INFO:index': { + name: 'SMART CAMERA INFO:index', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Retrieves the type of target for the indexed position in the smartcam list, counting from 0 (so index 0 is the first target in the list). */ + 'SMART_CAMERA_LIST:index': { + name: 'SMART CAMERA LIST:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This returns a localized string that represents the smartcam target specified by the given index. Indices count from 0 so index 0 is the first target in the list. */ + 'SMART_CAMERA_LIST_DESCRIPTION:index': { + name: 'SMART CAMERA LIST DESCRIPTION:index', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Difference of time between the current frame and the last frame where this SimObject has been animated */ + ANIMATION_DELTA_TIME: { + name: 'ANIMATION DELTA TIME', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** In case scenery is not loaded for AI planes, this variable can be used to set a default surface elevation. */ + ARTIFICIAL_GROUND_ELEVATION: { + name: 'ARTIFICIAL GROUND ELEVATION', + units: 'Feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** One of the following: + + "Airplane", + "Helicopter", + "Boat", + "GroundVehicle", + "ControlTower", + "SimpleObject", + "Viewer" */ + CATEGORY: { + name: 'CATEGORY', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** */ + CONTROLLABLE: { + name: 'CONTROLLABLE', + units: '', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Flag value that indicates the cause of a crash. */ + CRASH_FLAG: { + name: 'CRASH FLAG', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The state of the crash event sequence. */ + CRASH_SEQUENCE: { + name: 'CRASH SEQUENCE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Altitude of surface. */ + GROUND_ALTITUDE: { + name: 'GROUND ALTITUDE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** What frame of the hand is currently used. */ + HAND_ANIM_STATE: { + name: 'HAND ANIM STATE', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The ID of the idle animation for the sim object. */ + IDLE_ANIMATION_ID: { + name: 'IDLE ANIMATION ID', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** Magnetic variation. */ + MAGVAR: { + name: 'MAGVAR', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** */ + MISSION_SCORE: { + name: 'MISSION SCORE', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This will be TRUE if the parachute has opened and FALSE otherwise. Currently this is only applied to the Parachute SimObject used by Winches. */ + PARACHUTE_OPEN: { + name: 'PARACHUTE OPEN', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** General realism percent. */ + REALISM: { + name: 'REALISM', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** True indicates crash detection is turned on. */ + REALISM_CRASH_DETECTION: { + name: 'REALISM CRASH DETECTION', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** True indicates crashing with other aircraft is possible. */ + REALISM_CRASH_WITH_OTHERS: { + name: 'REALISM CRASH WITH OTHERS', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Is sim disabled. */ + SIM_DISABLED: { + name: 'SIM DISABLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** On ground flag. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + SIM_ON_GROUND: { + name: 'SIM ON GROUND', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** */ + SIM_SHOULD_SET_ON_GROUND: { + name: 'SIM SHOULD SET ON GROUND', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Returns true if Track IR is enabled or not. */ + TRACK_IR_ENABLE: { + name: 'TRACK IR ENABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Speed relative to the earths center. */ + TOTAL_WORLD_VELOCITY: { + name: 'TOTAL WORLD VELOCITY', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Is input allowed from the user. */ + USER_INPUT_ENABLED: { + name: 'USER INPUT ENABLED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** Model radius. */ + VISUAL_MODEL_RADIUS: { + name: 'VISUAL MODEL RADIUS', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Speed relative to earth, in East/West direction. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + VELOCITY_WORLD_X: { + name: 'VELOCITY WORLD X', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Speed relative to earth, in vertical direction. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + VELOCITY_WORLD_Y: { + name: 'VELOCITY WORLD Y', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Speed relative to earth, in North/South direction. + NOTE: This is available in multiplayer +to all far aircraft. See here for more information: +Note On SimVars In Multiplayer. */ + VELOCITY_WORLD_Z: { + name: 'VELOCITY WORLD Z', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Ambient density. */ + AMBIENT_DENSITY: { + name: 'AMBIENT DENSITY', + units: 'Slugs per cubic feet', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current precipitation rate. */ + AMBIENT_PRECIP_RATE: { + name: 'AMBIENT PRECIP RATE', + units: 'millimeters of water', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current state of precipitation. */ + AMBIENT_PRECIP_STATE: { + name: 'AMBIENT PRECIP STATE', + units: 'Mask:', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Ambient pressure. */ + AMBIENT_PRESSURE: { + name: 'AMBIENT PRESSURE', + units: 'Inches of mercury, inHg', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Ambient temperature. */ + AMBIENT_TEMPERATURE: { + name: 'AMBIENT TEMPERATURE', + units: 'Celsius', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Ambient visibility (only measures ambient particle visibility - related to ambient density). */ + AMBIENT_VISIBILITY: { + name: 'AMBIENT VISIBILITY', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Wind direction, relative to true north. */ + AMBIENT_WIND_DIRECTION: { + name: 'AMBIENT WIND DIRECTION', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Wind velocity. */ + AMBIENT_WIND_VELOCITY: { + name: 'AMBIENT WIND VELOCITY', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Wind component in East/West direction. */ + AMBIENT_WIND_X: { + name: 'AMBIENT WIND X', + units: 'Meters per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Wind component in vertical direction. */ + AMBIENT_WIND_Y: { + name: 'AMBIENT WIND Y', + units: 'Meters per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Wind component in North/South direction. */ + AMBIENT_WIND_Z: { + name: 'AMBIENT WIND Z', + units: 'Meters per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Barometric pressure. */ + BAROMETER_PRESSURE: { + name: 'BAROMETER PRESSURE', + units: 'Millibars', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The density altitude is the altitude relative to standard atmospheric conditions at which the air density would be equal to the indicated air density at the place of observation. The calculation is as follows: + density_altitude = pressure_altitude + 118.8 * (outside_air_temp +- ISA_temp) */ + DENSITY_ALTITUDE: { + name: 'DENSITY ALTITUDE', + units: 'ft', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Barometric pressure at sea level. */ + SEA_LEVEL_PRESSURE: { + name: 'SEA LEVEL PRESSURE', + units: 'Millibars', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** X (latitude), Y (vertical) and Z (longitude) components of the wind. */ + STRUCT_AMBIENT_WIND: { + name: 'STRUCT AMBIENT WIND', + units: 'Feet per second', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The desired speed of the AI object. */ + AI_DESIRED_SPEED: { + name: 'AI DESIRED SPEED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** A list of waypoints that an AI controlled object should follow. */ + AI_WAYPOINT_LIST: { + name: 'AI WAYPOINT LIST', + units: 'SIMCONNECT_DATA_WAYPOINT', + dataType: SimConnectDataType.WAYPOINT, + settable: true, + }, + /** The current waypoint in the list. */ + AI_CURRENT_WAYPOINT: { + name: 'AI CURRENT WAYPOINT', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The desired heading of the AI object. */ + AI_DESIRED_HEADING: { + name: 'AI DESIRED HEADING', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The time required by the AI aircraft to make a 90º turn. */ + AI_GROUNDTURNTIME: { + name: 'AI GROUNDTURNTIME', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The ground cruising speed for the AI aircraft. */ + AI_GROUNDCRUISESPEED: { + name: 'AI GROUNDCRUISESPEED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The ground turning speed for the AI aircraft. */ + AI_GROUNDTURNSPEED: { + name: 'AI GROUNDTURNSPEED', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This can be used to request whether the AI aircraft is IFR or VFR. Note that if an aircraft does not have a flight plan, the value returned will be 0 (or false). */ + AI_TRAFFIC_ISIFR: { + name: 'AI TRAFFIC ISIFR', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** This will return a string describing an AI aircraft state. If the aircraft is under ATC control the string will be one of the following: + + "init" + "sleep" + "flt plan" + "startup" + "preflight support" + "clearance" + "push back 1" + "push back 2" + "pre taxi out" + "taxi out" + "takeoff 1" + "takeoff 2" + "T&G depart" + "enroute" + "pattern" + "landing" + "rollout" + "go around" + "taxi in" + "shutdown" + "postflight support" + + + + + If the aircraft is not under ATC control, the string will be one of these: + + "Sleep" + "Waypoint" + "Takeoff" + "Landing" + "Taxi" + + + + Note that if an aircraft does not have a flight plan, the value returned will be an empty string "". */ + AI_TRAFFIC_STATE: { + name: 'AI TRAFFIC STATE', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The ICAO code of the current airport. +If an aircraft does not have a flight plan, the value returned will be an empty string "". */ + AI_TRAFFIC_CURRENT_AIRPORT: { + name: 'AI TRAFFIC CURRENT AIRPORT', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The assigned runway name (for example: "32R"). +If an aircraft does not have a flight plan, the value returned will be an empty string "". */ + AI_TRAFFIC_ASSIGNED_RUNWAY: { + name: 'AI TRAFFIC ASSIGNED RUNWAY', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The assigned parking name. The string will take the form: + Name + Number, Type ( radius ) + For example: + + "Ramp 1, RAMP sml (10m)" + "Gate G 4, RAMP lrg (18m)" + + If an aircraft does not have a flight plan, the value returned will be an empty string "". */ + AI_TRAFFIC_ASSIGNED_PARKING: { + name: 'AI TRAFFIC ASSIGNED PARKING', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The ICAO code of the departure airport in the current schedule. + + This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will an empty string"". */ + AI_TRAFFIC_FROMAIRPORT: { + name: 'AI TRAFFIC FROMAIRPORT', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The ICAO code of the destination airport in the current schedule. + + This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will an empty string"". */ + AI_TRAFFIC_TOAIRPORT: { + name: 'AI TRAFFIC TOAIRPORT', + units: 'String', + dataType: SimConnectDataType.STRINGV, + settable: false, + }, + /** The estimated time of departure for the current schedule entry, given as the number of seconds difference from the current simulation time. This can be negative if ETD is earlier than the current simulation time + This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will be 0. */ + AI_TRAFFIC_ETD: { + name: 'AI TRAFFIC ETD', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Estimated time of arrival for the current schedule entry, given as the number of seconds difference from the current simulated time. This can be negative if ETA is earlier than the current simulated time. + This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will be 0. */ + AI_TRAFFIC_ETA: { + name: 'AI TRAFFIC ETA', + units: 'Seconds', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Deprecated, do not use! */ + STRUCT_DAMAGEVISIBLE: { + name: 'STRUCT DAMAGEVISIBLE', + units: '-', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns a pitch, bank and heading value (for what will depend on the SimVar being used). */ + STRUCT_PBH32: { + name: 'STRUCT PBH32', + units: 'SIMCONNECT_DATA_XYZ', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** Not currently used in the simulation. */ + STRUCT_REALISM_VARS: { + name: 'STRUCT REALISM VARS', + units: '-', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The relative surface velocity. */ + STRUCT_SURFACE_RELATIVE_VELOCITY: { + name: 'STRUCT SURFACE RELATIVE VELOCITY', + units: 'SIMCONNECT_DATA_XYZ structure, feet per second', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** The world velocity. */ + STRUCT_WORLDVELOCITY: { + name: 'STRUCT WORLDVELOCITY', + units: 'SIMCONNECT_DATA_XYZ structure, feet per second', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** The world acceleration for each axis. Individual world acceleration values are in the Aircraft Position and Speed section. */ + STRUCT_WORLD_ACCELERATION: { + name: 'STRUCT WORLD ACCELERATION', + units: 'SIMCONNECT_DATA_XYZ structure, feet per second squared', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** The world rotation velocity. */ + STRUCT_WORLD_ROTATION_VELOCITY: { + name: 'STRUCT WORLD ROTATION VELOCITY', + units: 'SIMCONNECT_DATA_XYZ structure, radians per second', + dataType: SimConnectDataType.XYZ, + settable: false, + }, + /** The amount of bomb ammunition available. */ + BOMB_AMMO: { + name: 'BOMB AMMO', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The amount of cannon ammunition available. */ + CANNON_AMMO: { + name: 'CANNON AMMO', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The amount of gun ammunition available. */ + GUN_AMMO: { + name: 'GUN AMMO', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The amount of rocket ammunition available. */ + ROCKET_AMMO: { + name: 'ROCKET AMMO', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Current angle of the baggage loader ramp, relative to the ground. */ + BAGGAGELOADER_ANGLE_CURRENT: { + name: 'BAGGAGELOADER ANGLE CURRENT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Target angle of the baggage loader ramp, relative to the ground. */ + BAGGAGELOADER_ANGLE_TARGET: { + name: 'BAGGAGELOADER ANGLE TARGET', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** "Y" axis position of the end of the baggage loader ramp, relative to the ground. */ + BAGGAGELOADER_END_RAMP_Y: { + name: 'BAGGAGELOADER END RAMP Y', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** "Z" axis position of the end of the baggage loader ramp, relative to the ground. */ + BAGGAGELOADER_END_RAMP_Z: { + name: 'BAGGAGELOADER END RAMP Z', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** "Y" axis position of the baggage loader ramp pivot, relative to the ground. */ + BAGGAGELOADER_PIVOT_Y: { + name: 'BAGGAGELOADER PIVOT Y', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** "Z" axis position of the baggage loader ramp pivot, relative to the ground. */ + BAGGAGELOADER_PIVOT_Z: { + name: 'BAGGAGELOADER PIVOT Z', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current altitude +AGL of the top of the boarding ramp stairs. */ + BOARDINGRAMP_ELEVATION_CURRENT: { + name: 'BOARDINGRAMP ELEVATION CURRENT', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The target altitude AGL of the top of the boarding ramp stairs. */ + BOARDINGRAMP_ELEVATION_TARGET: { + name: 'BOARDINGRAMP ELEVATION TARGET', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The "Y" axis position of the top of the boarding ramp stairs when extended at maximal capacity, relative to the ground. */ + BOARDINGRAMP_END_POSITION_Y: { + name: 'BOARDINGRAMP END POSITION Y', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The "Z" axis position of the top of the boarding ramp stairs when extended at maximal capacity, relative to the ground. */ + BOARDINGRAMP_END_POSITION_Z: { + name: 'BOARDINGRAMP END POSITION Z', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current orientation of the boarding ramp stairs, where 0 is at rest and 1 is suited for boarding. */ + BOARDINGRAMP_ORIENTATION_CURRENT: { + name: 'BOARDINGRAMP ORIENTATION CURRENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The target orientation of of the boarding ramp stairs, where 0 is at rest and 1 is suited for boarding. */ + BOARDINGRAMP_ORIENTATION_TARGET: { + name: 'BOARDINGRAMP ORIENTATION TARGET', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The "Y" axis +position of the top of the boarding ramp stairs when at minimal extension, relative to the ground. */ + BOARDINGRAMP_START_POSITION_Y: { + name: 'BOARDINGRAMP START POSITION Y', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The "Z" axis +position of the top of the boarding ramp stairs when at minimal extension, relative to the ground. */ + BOARDINGRAMP_START_POSITION_Z: { + name: 'BOARDINGRAMP START POSITION Z', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The "Z" axis position of the point of contact between the catering truck and the bottom of the aircraft door, relative to the ground. */ + CATERINGTRUCK_AIRCRAFT_DOOR_CONTACT_OFFSET_Z: { + name: 'CATERINGTRUCK AIRCRAFT DOOR CONTACT OFFSET Z', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current altitude AGL of the bottom of the catering truck container. */ + CATERINGTRUCK_ELEVATION_CURRENT: { + name: 'CATERINGTRUCK ELEVATION CURRENT', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The target altitude AGL of the bottom of the catering truck container. */ + CATERINGTRUCK_ELEVATION_TARGET: { + name: 'CATERINGTRUCK ELEVATION TARGET', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The current state of the catering truck when opening the container and deploying the bridge, where 0 is fully closed and 1 is fully opened and deployed. */ + CATERINGTRUCK_OPENING_CURRENT: { + name: 'CATERINGTRUCK OPENING CURRENT', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The target state of the catering truck the container is opene and the bridge deployed, where 0 is fully closed and 1 is fully opened and deployed. */ + CATERINGTRUCK_OPENING_TARGET: { + name: 'CATERINGTRUCK OPENING TARGET', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The current deployment amount of the fuel truck hose. Currently can only be set to 0 (not deployed) and 1 (deployed). */ + FUELTRUCK_HOSE_DEPLOYED: { + name: 'FUELTRUCK HOSE DEPLOYED', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The "X" axis position of the end of the fuel truck hose when fully deployed, relative to the ground. */ + FUELTRUCK_HOSE_END_POSX: { + name: 'FUELTRUCK HOSE END POSX', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The "Z" axis position of the end of the fuel truck hose when fully deployed, relative to the ground. */ + FUELTRUCK_HOSE_END_POSZ: { + name: 'FUELTRUCK HOSE END POSZ', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The heading of the end of the fuel truck hose, relative to the vehicle heading. */ + FUELTRUCK_HOSE_END_RELATIVE_HEADING: { + name: 'FUELTRUCK HOSE END RELATIVE HEADING', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current deployment amount of the ground power unit hose. Currently can only be set to 0 (not deployed) and 1 (deployed). */ + GROUNDPOWERUNIT_HOSE_DEPLOYED: { + name: 'GROUNDPOWERUNIT HOSE DEPLOYED', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The "X" axis position of the end of the ground power unit hose when fully deployed, relative to the ground. */ + GROUNDPOWERUNIT_HOSE_END_POSX: { + name: 'GROUNDPOWERUNIT HOSE END POSX', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The "Z" axis position of the end of the ground power unit hose when fully deployed, relative to the ground. */ + GROUNDPOWERUNIT_HOSE_END_POSZ: { + name: 'GROUNDPOWERUNIT HOSE END POSZ', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The heading of the end of the ground power unit hose, relative to the vehicle heading. */ + GROUNDPOWERUNIT_HOSE_END_RELATIVE_HEADING: { + name: 'GROUNDPOWERUNIT HOSE END RELATIVE HEADING', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The target position for the left bend animation of the jetway hood. */ + JETWAY_HOOD_LEFT_BEND: { + name: 'JETWAY HOOD LEFT BEND', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The target angle for the left deployment animation of the jetway hood, where 0 is considered vertical. */ + JETWAY_HOOD_LEFT_DEPLOYMENT: { + name: 'JETWAY HOOD LEFT DEPLOYMENT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The target position for the right bend animation of the jetway hood. */ + JETWAY_HOOD_RIGHT_BEND: { + name: 'JETWAY HOOD RIGHT BEND', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The target angle for the right deployment animation of the jetway hood, where 0 is considered vertical. */ + JETWAY_HOOD_RIGHT_DEPLOYMENT: { + name: 'JETWAY HOOD RIGHT DEPLOYMENT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Target position for the top horizontal animation of the jetway hood. Values can be between -100% and 100%. */ + JETWAY_HOOD_TOP_HORIZONTAL: { + name: 'JETWAY HOOD TOP HORIZONTAL', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Target position for the top vertical animation of the jetway hood. Values can be between -100% and 100%. */ + JETWAY_HOOD_TOP_VERTICAL: { + name: 'JETWAY HOOD TOP VERTICAL', + units: 'Percent', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** This will be 1 (TRUE) id the jetway +body +is currently moving (it will not include checks on hood animation). */ + JETWAY_MOVING: { + name: 'JETWAY MOVING', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The current angle of the jetway wheels. */ + JETWAY_WHEEL_ORIENTATION_CURRENT: { + name: 'JETWAY WHEEL ORIENTATION CURRENT', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The (approximate) target angle for the jetway wheels. */ + JETWAY_WHEEL_ORIENTATION_TARGET: { + name: 'JETWAY WHEEL ORIENTATION TARGET', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The current speed of the jetway wheels. */ + JETWAY_WHEEL_SPEED: { + name: 'JETWAY WHEEL SPEED', + units: 'Meters per second', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** Currently not used in the simulation. */ + MARSHALLER_AIRCRAFT_DIRECTION_PARKINGSPACE: { + name: 'MARSHALLER AIRCRAFT DIRECTION PARKINGSPACE', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The distance between the Marshaller and the aircraft. */ + MARSHALLER_AIRCRAFT_DISTANCE: { + name: 'MARSHALLER AIRCRAFT DISTANCE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Position on the X axis of the aircraft in the parking space (negative means the aircraft is on the left side and positive the right side). */ + MARSHALLER_AIRCRAFT_DISTANCE_DIRECTION_X_PARKINGSPACE: { + name: 'MARSHALLER AIRCRAFT DISTANCE DIRECTION X PARKINGSPACE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Position on the Z axis of the aircraft in the parking space (negative means the aircraft is behind the parking space and positive is in front of the parking space). */ + MARSHALLER_AIRCRAFT_DISTANCE_DIRECTION_Z_PARKINGSPACE: { + name: 'MARSHALLER AIRCRAFT DISTANCE DIRECTION Z PARKINGSPACE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if the engine(s) of the aircraft is (are) shut down. */ + MARSHALLER_AIRCRAFT_ENGINE_SHUTDOWN: { + name: 'MARSHALLER AIRCRAFT ENGINE SHUTDOWN', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Angle between the direction of the aircraft and the direction of the parking place. */ + MARSHALLER_AIRCRAFT_HEADING_PARKINGSPACE: { + name: 'MARSHALLER AIRCRAFT HEADING PARKINGSPACE', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Value in Z axis of the projection from the aircraft position following the heading of the aircraft. */ + MARSHALLER_AIRCRAFT_PROJECTION_POINT_PARKINGSPACE: { + name: 'MARSHALLER AIRCRAFT PROJECTION POINT PARKINGSPACE', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The velocity of the aircraft. */ + MARSHALLER_AIRCRAFT_VELOCITY: { + name: 'MARSHALLER AIRCRAFT VELOCITY', + units: 'Knots', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Pushback angle (the heading of the tug). */ + PUSHBACK_ANGLE: { + name: 'PUSHBACK ANGLE', + units: 'Radians', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** True if this vehicle is attached to an aircraft. */ + PUSHBACK_ATTACHED: { + name: 'PUSHBACK ATTACHED', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** True if a push back is available on the parking space. */ + PUSHBACK_AVAILABLE: { + name: 'PUSHBACK AVAILABLE', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** The towpoint position, relative to the aircrafts datum reference point. */ + PUSHBACK_CONTACTX: { + name: 'PUSHBACK CONTACTX', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Pushback contact position in vertical direction. */ + PUSHBACK_CONTACTY: { + name: 'PUSHBACK CONTACTY', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Pushback contact position in fore/aft direction. */ + PUSHBACK_CONTACTZ: { + name: 'PUSHBACK CONTACTZ', + units: 'Feet (ft)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Type of pushback. */ + 'PUSHBACK_STATE:index': { + name: 'PUSHBACK STATE:index', + units: 'Enum:', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** True if waiting for pushback. */ + PUSHBACK_WAIT: { + name: 'PUSHBACK WAIT', + units: 'Bool', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The length of the link at the back of the vehicle used to attach a wagon behind. */ + WAGON_BACK_LINK_LENGTH: { + name: 'WAGON BACK LINK LENGTH', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current orientation of the link at the back of the vehicle used to attach a wagon behind. */ + WAGON_BACK_LINK_ORIENTATION: { + name: 'WAGON BACK LINK ORIENTATION', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The "Z" axis position of the start of the link at the back of the vehicle used to attach a wagon behind, relative to the ground. */ + WAGON_BACK_LINK_START_POSZ: { + name: 'WAGON BACK LINK START POSZ', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The length of the link at the front of the vehicle used to be attached as wagon. */ + WAGON_FRONT_LINK_LENGTH: { + name: 'WAGON FRONT LINK LENGTH', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current orientation of the link at the front of the vehicle used to be attached as wagon. */ + WAGON_FRONT_LINK_ORIENTATION: { + name: 'WAGON FRONT LINK ORIENTATION', + units: 'Degrees', + dataType: SimConnectDataType.FLOAT64, + settable: true, + }, + /** The "Z" axis position of the start of the link at the front of the vehicle used to be attached as wagon, relative to the ground. */ + WAGON_FRONT_LINK_START_POSZ: { + name: 'WAGON FRONT LINK START POSZ', + units: 'Meters', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, +} as const satisfies { [key: string]: PredefinedVariable }; + +export type SimvarPredefinitions = typeof simvarPredefinitions; diff --git a/samples/typescript/apiHelper.ts b/samples/typescript/apiHelper.ts index cccdba9..b457bfd 100644 --- a/samples/typescript/apiHelper.ts +++ b/samples/typescript/apiHelper.ts @@ -1,5 +1,5 @@ -import { ApiHelper } from '../../dist/apiHelper'; -import { open, Protocol, SimConnectDataType } from '../../dist'; +import { ApiHelper } from '../../dist/src/apiHelper'; +import { open, Protocol, SimConnectDataType } from '../../dist/src'; open('API-helper example', Protocol.KittyHawk) .then(async ({ recvOpen, handle }) => { @@ -19,53 +19,35 @@ async function doStuff(apiHelper: ApiHelper) { }); /** Get a set of simulation variables once */ - simulationVariables - .request({ - TITLE: { - units: null, - dataType: SimConnectDataType.STRING128, - }, - CATEGORY: { - units: null, - dataType: SimConnectDataType.STRING128, - }, - 'FUEL TOTAL QUANTITY': { - units: 'liters', - dataType: SimConnectDataType.INT32, - }, - }) - .then(data => { - console.log( - `Current aircraft is '${data.TITLE}'. It has ${data['FUEL TOTAL QUANTITY']} liters of fuel on board` - ); - }) - .catch(err => console.log(err)); + const aircraftTitle = await simulationVariables.get('TITLE'); + const atcMdel = await simulationVariables.get('ATC_MODEL'); + const fuelOnBoard = await simulationVariables.get('FUEL_TOTAL_QUANTITY'); + const fuelOnBoardKgs = await simulationVariables.get({ + name: 'FUEL_TOTAL_QUANTITY', + units: 'kilograms', + dataType: SimConnectDataType.FLOAT64, + }); + + console.log( + `Current aircraft is '${aircraftTitle}' (${atcMdel}). It has ${fuelOnBoard} gallons (${fuelOnBoardKgs} kgs) of fuel on board` + ); /** Get simulation variables whenever they change */ simulationVariables.monitor( - { - 'AIRSPEED INDICATED': { - units: 'knots', - dataType: SimConnectDataType.INT32, - }, - 'STRUCT LATLONALT': { - units: null, - dataType: SimConnectDataType.LATLONALT, - }, - }, + ['AIRSPEED_INDICATED', 'STRUCT_LATLONALT'], (err, data) => { if (err) { console.log(err); } else if (data) { - console.log('Airspeed:', data['AIRSPEED INDICATED']); - console.log('Altitude:', data['STRUCT LATLONALT'].altitude); + console.log('Airspeed:', data.AIRSPEED_INDICATED); + console.log('Altitude:', data.STRUCT_LATLONALT.altitude); } }, { onlyOnChange: true } ); /** Set throttles to 50% */ - simulationVariables.set( + /*simulationVariables.set( { 'GENERAL ENG THROTTLE LEVER POSITION:1': { value: 50, @@ -79,7 +61,7 @@ async function doStuff(apiHelper: ApiHelper) { }, }, err => console.log(err) - ); + );*/ /** * The property names and corresponding data types are defined here: diff --git a/src/ApiHelper/SimulationVariablesHelper.ts b/src/ApiHelper/SimulationVariablesHelper.ts index efc6778..cb8dd1f 100644 --- a/src/ApiHelper/SimulationVariablesHelper.ts +++ b/src/ApiHelper/SimulationVariablesHelper.ts @@ -8,17 +8,68 @@ import { SimObjectType } from '../enums/SimObjectType'; import { SimConnectException } from '../enums/SimConnectException'; import { BaseHelper } from './BaseHelper'; import { JavascriptDataType, readSimConnectValue, writeSimConnectValue } from './utils'; - -export type SimvarCallback = ( - err: SimConnectError | null, - data: VariablesResponse | null -) => void; +import { simvarPredefinitions, SimvarPredefinitions } from '../../generated/simvars'; export type SimConnectError = { message: string; exception: SimConnectException; }; +type RequestedSimulationVariable = CustomSimulationVariableRequest | keyof SimvarPredefinitions; + +/** + * Used for requesting a simulation variable that is not predefined, or for requesting a predefined variable with different units. + */ +type CustomSimulationVariableRequest = { + name: string; + units: string | null; + dataType: SimConnectDataType; + epsilon?: number; +}; + +/** + * A callback for when subscription data is received + */ +export type SimvarCallback = ( + err: SimConnectError | null, + data: VariablesResponse | null +) => void; + +/** + * The output object structure when requesting multiple simulation variables + */ +type VariablesResponse = { + [U in T as SimulationVariableName]: SimulationVariableType; +}; + +/** + * The output type of the requested simulation variable + */ +type SimulationVariableType = + Var extends keyof SimvarPredefinitions + ? JavascriptDataType[SimvarPredefinitions[Var] extends { + dataType: infer D extends keyof JavascriptDataType; + } + ? D + : never] + : Var extends CustomSimulationVariableRequest + ? JavascriptDataType[Var['dataType']] + : never; + +/** + * The name of the requested simulation variable + */ +type SimulationVariableName = + T extends keyof SimvarPredefinitions + ? T + : T extends CustomSimulationVariableRequest + ? T['name'] + : never; + +type VariablesToSet = { + [propName in T]: JavascriptDataType[(typeof simvarPredefinitions)[propName]['dataType']]; +}; + class SimulationVariablesHelper extends BaseHelper { private _nextDataDefinitionId: number; @@ -30,19 +81,37 @@ class SimulationVariablesHelper extends BaseHelper { this._nextDataRequestId = 0; } + /** + * Read a simulation variable once + * @param simulationVariable The variable to retrieve + * @param simObjectId Defaults to the user's aircraft + */ + async get( + simulationVariable: T, + simObjectId: number = SimConnectConstants.OBJECT_ID_USER + ) { + return this.getAll([simulationVariable], simObjectId).then( + data => Object.values(data)[0] as SimulationVariableType + ); + } + /** * Read a set of simulation variables once - * @param requestStructure - * @param simObjectId + * @param simulationVariables The variables to retrieve + * @param simObjectId Defaults to the user's aircraft */ - async request( - requestStructure: T, + async getAll( + simulationVariables: T[], simObjectId: number = SimConnectConstants.OBJECT_ID_USER ): Promise> { return new Promise((resolve, reject) => { let hasFailed = false; + const simulationVariableRequests = simulationVariables.map( + toStandardizedSimulationVariableRequest + ); + const sub = this._makeSubscription({ - requestStructure, + simulationVariableRequests, simObjectId, period: SimConnectPeriod.ONCE, errorHandler: error => { @@ -58,7 +127,7 @@ class SimulationVariablesHelper extends BaseHelper { sub.defineId === recvSimObjectData.defineID ) { resolve( - extractDataStructureFromBuffer(requestStructure, recvSimObjectData.data) + extractVariablesFromBuffer(simulationVariables, recvSimObjectData.data) ); this._handle.clearDataDefinition(sub.defineId); } @@ -68,27 +137,28 @@ class SimulationVariablesHelper extends BaseHelper { /** * Updates a set of simulation variables - * @param variablesToSet + * @param variablesToSet The variables to update * @param errorHandler Called in case of an error - * @param simObjectId + * @param simObjectId Defaults to the user's aircraft */ - set( - variablesToSet: T, + set( + variablesToSet: VariablesToSet, errorHandler?: (err: SimConnectError) => void, simObjectId = SimConnectConstants.OBJECT_ID_USER ) { - const defineId = this._createDataDefinition( - variablesToSet, + const vars = Object.keys(variablesToSet).map(name => simvarPredefinitions[name as T]); + const values = Object.values( + variablesToSet + ) as JavascriptDataType[(typeof vars)[number]['dataType']][]; + + const defineId = this._createDataDefinition2( + vars, error => errorHandler && errorHandler(error) ); const rawBuffer = new RawBuffer(0); - Object.keys(variablesToSet).forEach(name => { - writeSimConnectValue( - rawBuffer, - variablesToSet[name].value, - variablesToSet[name].dataType - ); + vars.forEach((simvar, index) => { + writeSimConnectValue(rawBuffer, values[index], simvar.dataType); }); const sendId = this._handle.setDataOnSimObject(defineId, simObjectId, { @@ -111,15 +181,15 @@ class SimulationVariablesHelper extends BaseHelper { /** * Continuously read a set of simulation variables - * @param simulationVariables - * @param callback - * @param options - * @param options.onlyOnChange If the callback should trigger only when one of the variables change + * @param simulationVariables The variables to monitor + * @param callback Called when the variables change + * @param options Additional options + * @param options.onlyOnChange If the callback should trigger only when a variable changes * @param options.simObjectId Defaults to the user's aircraft - * @param {SimConnectPeriod} options.interval + * @param {SimConnectPeriod} options.interval Defaults to SimConnectPeriod.SIM_FRAME */ - monitor( - simulationVariables: T, + monitor( + simulationVariables: T[], callback: SimvarCallback, options?: { onlyOnChange?: boolean; @@ -127,9 +197,14 @@ class SimulationVariablesHelper extends BaseHelper { interval?: SimConnectPeriod; } ) { + const simulationVariableRequests = simulationVariables.map( + toStandardizedSimulationVariableRequest + ); + let hasFailed = false; + const sub = this._makeSubscription({ - requestStructure: simulationVariables, + simulationVariableRequests, simObjectId: options?.simObjectId || SimConnectConstants.OBJECT_ID_USER, period: options?.interval || SimConnectPeriod.SIM_FRAME, flags: options?.onlyOnChange ? DataRequestFlag.DATA_REQUEST_FLAG_CHANGED : 0, @@ -148,7 +223,10 @@ class SimulationVariablesHelper extends BaseHelper { ) { callback( null, - extractDataStructureFromBuffer(simulationVariables, recvSimObjectData.data) + extractVariablesFromBuffer( + simulationVariableRequests, + recvSimObjectData.data + ) as VariablesResponse ); } }); @@ -156,19 +234,21 @@ class SimulationVariablesHelper extends BaseHelper { /** * Read simulation variables for a certain object type - * @param type + * @param type The type of object to monitor * @param radiusMeters Radius from user's aircraft - * @param simulationVariables - * @param callback + * @param simulationVariables The variables to monitor + * @param callback Called when the variables change */ - monitorObjects( + monitorObjects( type: SimObjectType, radiusMeters: number, - simulationVariables: T, + simulationVariables: T[], callback: SimvarCallback ) { const sub = this._makeSubscriptionByType({ - requestStructure: simulationVariables, + simulationVariableRequests: simulationVariables.map( + toStandardizedSimulationVariableRequest + ), radiusMeters, type, errorHandler: err => callback(err, null), @@ -181,21 +261,24 @@ class SimulationVariablesHelper extends BaseHelper { ) { callback( null, - extractDataStructureFromBuffer(simulationVariables, recvSimObjectData.data) + extractVariablesFromBuffer(simulationVariables, recvSimObjectData.data) ); // this._handle.clearDataDefinition(sub.defineId); } }); } - private _makeSubscription(params: { - requestStructure: T; + private _makeSubscription(params: { + simulationVariableRequests: CustomSimulationVariableRequest[]; period: SimConnectPeriod; simObjectId: number; flags?: number; errorHandler: (error: SimConnectError) => void; }): { defineId: number; requestId: number } { - const defineId = this._createDataDefinition(params.requestStructure, params.errorHandler); + const defineId = this._createDataDefinition2( + params.simulationVariableRequests, + params.errorHandler + ); const requestId = this._nextDataRequestId++; const sendId = this._handle.requestDataOnSimObject( @@ -216,15 +299,18 @@ class SimulationVariablesHelper extends BaseHelper { return { requestId, defineId }; } - private _makeSubscriptionByType(params: { - requestStructure: T; + private _makeSubscriptionByType(params: { + simulationVariableRequests: CustomSimulationVariableRequest[]; radiusMeters: number; type: SimObjectType; errorHandler: (error: SimConnectError) => void; }): { defineId: number; requestId: number } { const requestId = this._nextDataRequestId++; - const defineId = this._createDataDefinition(params.requestStructure, params.errorHandler); + const defineId = this._createDataDefinition2( + params.simulationVariableRequests, + params.errorHandler + ); const sendId = this._handle.requestDataOnSimObjectType( requestId, @@ -243,30 +329,27 @@ class SimulationVariablesHelper extends BaseHelper { return { requestId, defineId }; } - private _createDataDefinition( - requestStructure: T, + private _createDataDefinition2( + requestedSimvars: T[], errorHandler: (error: SimConnectError) => void ): number { const defineId = this._nextDataDefinitionId++; /** - * We register the simulation variables in reverse order, so we receive them in the same order - * that they were defined in the requestStructure (because the result looks more professional). + * We register the simulation variables in reverse order, so we receive them + * in the same order that they were defined in the requestedSimvars list. */ - const variableNames = Object.keys(requestStructure).reverse(); - const variableDefinitions = Object.values(requestStructure).reverse(); - - variableDefinitions.forEach((requestedValue, index) => { + requestedSimvars.reverse().forEach(requestedValue => { const sendId = this._handle.addToDataDefinition( defineId, - variableNames[index], + requestedValue.name, requestedValue.units, requestedValue.dataType, requestedValue.epsilon ); this._checkForException(sendId, ex => errorHandler({ - message: `Something is wrong with the definition of '${variableNames[index]}': ${SimConnectException[ex]}`, + message: `Something is wrong with the definition of '${requestedValue.name}': ${SimConnectException[ex]}`, exception: ex, }) ); @@ -276,44 +359,37 @@ class SimulationVariablesHelper extends BaseHelper { } } -function extractDataStructureFromBuffer( - requestStructure: T, +function extractVariablesFromBuffer( + requestedSimvars: T[], rawBuffer: RawBuffer -) { - return Object.keys(requestStructure) +): VariablesResponse { + return requestedSimvars + .map(toStandardizedSimulationVariableRequest) .reverse() // Reverse to get the same order as requested order .reduce( - (result, variableName) => ({ - [variableName]: readSimConnectValue( - rawBuffer, - requestStructure[variableName].dataType - ), + (result, simvar) => ({ + [simvar.name]: readSimConnectValue(rawBuffer, simvar.dataType), ...result, }), {} as VariablesResponse ); } -// Types: - -type SimulationVariable = { - units: string | null; - dataType: SimConnectDataType; - epsilon?: number; -}; - -type VariablesToSet = { - [propName: string]: SimulationVariable & { - value: JavascriptDataType[SimulationVariable['dataType']]; - }; -}; - -type VariablesToGet = { - [propName: string]: SimulationVariable; -}; - -type VariablesResponse = { - [K in keyof R]: JavascriptDataType[R[K]['dataType']]; -}; +function toStandardizedSimulationVariableRequest( + simvar: RequestedSimulationVariable +): CustomSimulationVariableRequest { + if (typeof simvar === 'string') { + const predefinition = simvarPredefinitions[simvar as keyof SimvarPredefinitions]; + return { + name: predefinition.name, + units: predefinition.units, + dataType: predefinition.dataType, + }; + } + if (simvar.name !== undefined && simvar.units !== undefined && simvar.dataType !== undefined) { + return simvar; + } + throw new Error('Invalid simvar request'); +} export { SimulationVariablesHelper }; diff --git a/src/index.ts b/src/index.ts index cc2af10..45e845e 100644 --- a/src/index.ts +++ b/src/index.ts @@ -12,6 +12,7 @@ export * from './datastructures'; export * from './Types'; export * from './recv'; export * from './dto'; +export * from './ApiHelper'; export { RawBuffer } from './RawBuffer'; /** From 124ea437752b8f22890297a0aa6b769c06d1d111 Mon Sep 17 00:00:00 2001 From: Even Rognlien Date: Sun, 4 Feb 2024 22:23:31 +0100 Subject: [PATCH 09/12] Include script that scrapes the offical docs for simulation variables --- package-lock.json | 203 ++++++++++++++++++++++++++++++++ package.json | 2 + samples/typescript/apiHelper.ts | 18 +-- tsconfig.json | 8 +- utils/packetInspectorProxy.ts | 100 ---------------- 5 files changed, 215 insertions(+), 116 deletions(-) delete mode 100644 utils/packetInspectorProxy.ts diff --git a/package-lock.json b/package-lock.json index 187ee45..c697e07 100644 --- a/package-lock.json +++ b/package-lock.json @@ -22,6 +22,7 @@ "@types/jest": "^29.2.4", "@typescript-eslint/eslint-plugin": "^6.20.0", "@typescript-eslint/parser": "^6.20.0", + "cheerio": "^1.0.0-rc.12", "eslint": "^8.56.0", "eslint-config-airbnb-base": "^15.0.0", "eslint-config-airbnb-typescript": "^17.1.0", @@ -33,6 +34,7 @@ "husky": "^8.0.1", "jest": "^29.3.1", "lint-staged": "^12.4.2", + "outdent": "^0.8.0", "prettier": "^3.2.5", "pretty-quick": "^4.0.0", "ts-jest": "^29.0.3", @@ -2006,6 +2008,12 @@ "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=", "dev": true }, + "node_modules/boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", + "dev": true + }, "node_modules/brace-expansion": { "version": "1.1.11", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", @@ -2167,6 +2175,44 @@ "node": ">=10" } }, + "node_modules/cheerio": { + "version": "1.0.0-rc.12", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.12.tgz", + "integrity": "sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==", + "dev": true, + "dependencies": { + "cheerio-select": "^2.1.0", + "dom-serializer": "^2.0.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1", + "htmlparser2": "^8.0.1", + "parse5": "^7.0.0", + "parse5-htmlparser2-tree-adapter": "^7.0.0" + }, + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/cheeriojs/cheerio?sponsor=1" + } + }, + "node_modules/cheerio-select": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz", + "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==", + "dev": true, + "dependencies": { + "boolbase": "^1.0.0", + "css-select": "^5.1.0", + "css-what": "^6.1.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, "node_modules/ci-info": { "version": "3.7.0", "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.7.0.tgz", @@ -2386,6 +2432,34 @@ "node": ">= 8" } }, + "node_modules/css-select": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz", + "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==", + "dev": true, + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.1.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-what": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz", + "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==", + "dev": true, + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, "node_modules/debug": { "version": "4.3.4", "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", @@ -2487,6 +2561,61 @@ "node": ">=6.0.0" } }, + "node_modules/dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "dev": true, + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/domelementtype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz", + "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ] + }, + "node_modules/domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "dev": true, + "dependencies": { + "domelementtype": "^2.3.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/domutils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.1.0.tgz", + "integrity": "sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==", + "dev": true, + "dependencies": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, "node_modules/eastasianwidth": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", @@ -2517,6 +2646,18 @@ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true }, + "node_modules/entities": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", + "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", + "dev": true, + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, "node_modules/error-ex": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", @@ -3641,6 +3782,25 @@ "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", "dev": true }, + "node_modules/htmlparser2": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz", + "integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==", + "dev": true, + "funding": [ + "https://github.com/fb55/htmlparser2?sponsor=1", + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1", + "entities": "^4.4.0" + } + }, "node_modules/husky": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/husky/-/husky-8.0.1.tgz", @@ -5303,6 +5463,18 @@ "node": ">=8" } }, + "node_modules/nth-check": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", + "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==", + "dev": true, + "dependencies": { + "boolbase": "^1.0.0" + }, + "funding": { + "url": "https://github.com/fb55/nth-check?sponsor=1" + } + }, "node_modules/object-inspect": { "version": "1.13.1", "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.1.tgz", @@ -5440,6 +5612,12 @@ "node": ">= 0.8.0" } }, + "node_modules/outdent": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/outdent/-/outdent-0.8.0.tgz", + "integrity": "sha512-KiOAIsdpUTcAXuykya5fnVVT+/5uS0Q1mrkRHcF89tpieSmY33O/tmc54CqwA+bfhbtEfZUNLHaPUiB9X3jt1A==", + "dev": true + }, "node_modules/p-limit": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", @@ -5521,6 +5699,31 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/parse5": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.1.2.tgz", + "integrity": "sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==", + "dev": true, + "dependencies": { + "entities": "^4.4.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parse5-htmlparser2-tree-adapter": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.0.0.tgz", + "integrity": "sha512-B77tOZrqqfUfnVcOrUvfdLbz4pu4RopLD/4vmu3HUPswwTA8OH0EMW9BlWR2B0RCoiZRAHEUu7IxeP1Pd1UU+g==", + "dev": true, + "dependencies": { + "domhandler": "^5.0.2", + "parse5": "^7.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, "node_modules/path-exists": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", diff --git a/package.json b/package.json index b305ba2..8061880 100644 --- a/package.json +++ b/package.json @@ -41,6 +41,7 @@ "@types/jest": "^29.2.4", "@typescript-eslint/eslint-plugin": "^6.20.0", "@typescript-eslint/parser": "^6.20.0", + "cheerio": "^1.0.0-rc.12", "eslint": "^8.56.0", "eslint-config-airbnb-base": "^15.0.0", "eslint-config-airbnb-typescript": "^17.1.0", @@ -52,6 +53,7 @@ "husky": "^8.0.1", "jest": "^29.3.1", "lint-staged": "^12.4.2", + "outdent": "^0.8.0", "prettier": "^3.2.5", "pretty-quick": "^4.0.0", "ts-jest": "^29.0.3", diff --git a/samples/typescript/apiHelper.ts b/samples/typescript/apiHelper.ts index b457bfd..0354ef8 100644 --- a/samples/typescript/apiHelper.ts +++ b/samples/typescript/apiHelper.ts @@ -47,21 +47,9 @@ async function doStuff(apiHelper: ApiHelper) { ); /** Set throttles to 50% */ - /*simulationVariables.set( - { - 'GENERAL ENG THROTTLE LEVER POSITION:1': { - value: 50, - units: 'Percent', - dataType: SimConnectDataType.INT32, - }, - 'GENERAL ENG THROTTLE LEVER POSITION:2': { - value: 50, - units: 'Percent', - dataType: SimConnectDataType.INT32, - }, - }, - err => console.log(err) - );*/ + simulationVariables.set(['GENERAL ENG THROTTLE LEVER POSITION:1', 50, 'Percent'], err => + console.log(err) + ); /** * The property names and corresponding data types are defined here: diff --git a/tsconfig.json b/tsconfig.json index b93a617..994f2b7 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -11,5 +11,11 @@ "inlineSourceMap": true, "inlineSources": true }, - "include": ["src/**/*", "tests/**/*", "utils/**/*"] + "include": [ + "src/**/*", + "tests/**/*", + "utils/**/*", + "scripts/scrapeSimvars.ts", + "scripts/packetInspectorProxy.ts" + ] } diff --git a/utils/packetInspectorProxy.ts b/utils/packetInspectorProxy.ts deleted file mode 100644 index 1fc611a..0000000 --- a/utils/packetInspectorProxy.ts +++ /dev/null @@ -1,100 +0,0 @@ -/** - * To run this file: "npx ts-node .\utils\packetInspectorProxy.ts" - * - * Starts a proxy server that can be used to inspect packages sent between - * the SimConnect server and a client application. Inspired by - * https://github.com/Dragonlaird/SimConnect_Proxy - * - * Requires SimConnect network setup. Create a SimConnect.xml in the following directory: - * X:\Users\\AppData\Local\Packages\Microsoft.FlightSimulator_**********\LocalCache - * - * - * - * SimConnect.xml - * - * IPv4 - * local - * 500 - * 64 - * 41088 - *
0.0.0.0
- * - * - * - * - * Create a SimConnect.cfg file next to the client application .exe: - * - * [SimConnect] - * Protocol=Ipv4 - * Port=1337 # Must match the proxy server's port number - * Address=127.0.0.1 - */ - -import * as net from 'net'; - -const proxyHost = '127.0.0.1'; -const proxyPort = 1337; - -const simConnectHost = '127.0.0.1'; -const simConnectPort = 500; // Must match the port number in SimConnect.xml - -const server = net.createServer(clientSocket => { - const targetSocket = net.connect(simConnectPort, simConnectHost, () => { - console.log(`Proxy connected to target server: ${simConnectHost}:${simConnectPort}`); - - clientSocket.on('data', data => { - console.log( - `[Application -> SimConnect] ${data.length} bytes ::::::::::::::::::::::::\n` - ); - const hexString = formatAndPrint(data); - - targetSocket.write(data); - targetSocket.write(Buffer.from(hexString, 'hex')); // Forwarding the data to the target server - }); - - targetSocket.on('data', data => { - console.log( - `[SimConnect -> Application] ${data.length} bytes ::::::::::::::::::::::::\n` - ); - const hexString = formatAndPrint(data); - - clientSocket.write(data); - clientSocket.write(Buffer.from(hexString, 'hex')); // Forwarding the data to the client - }); - - clientSocket.on('end', () => { - console.log('Client disconnected'); - targetSocket.end(); - }); - - targetSocket.on('end', () => { - console.log('Target server disconnected'); - clientSocket.end(); - }); - - clientSocket.on('error', err => console.error(`Client socket error: ${err.message}`)); - targetSocket.on('error', err => console.error(`Target socket error: ${err.message}`)); - }); - - clientSocket.on('end', () => { - console.log('Client disconnected'); - targetSocket.end(); - }); - - clientSocket.on('error', err => console.error(`Client socket error: ${err.message}`)); -}); - -server.listen(proxyPort, proxyHost, () => { - console.log(`Proxy server listening on ${proxyHost}:${proxyPort}`); -}); - -function formatAndPrint(data: Buffer): string { - const hexString = data.toString('hex'); - for (let i = 0; i < hexString.length; i += 32) { - const slice = hexString.slice(i, i + 32); - const utf8String = Buffer.from(slice, 'hex').toString('utf-8'); - console.log(`${slice.match(/.{1,8}/g)?.join(' ')}\t\t${utf8String}`); - } - console.log('\n\n'); - return hexString; // Return the original hex string for forwarding -} From a3eff164338142fcdfdead7f67635531793cdc45 Mon Sep 17 00:00:00 2001 From: Even Rognlien Date: Sun, 4 Feb 2024 22:25:41 +0100 Subject: [PATCH 10/12] Fix build --- tsconfig.json | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/tsconfig.json b/tsconfig.json index 994f2b7..af6c7f7 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -11,11 +11,5 @@ "inlineSourceMap": true, "inlineSources": true }, - "include": [ - "src/**/*", - "tests/**/*", - "utils/**/*", - "scripts/scrapeSimvars.ts", - "scripts/packetInspectorProxy.ts" - ] + "include": ["src/**/*", "tests/**/*", "utils/**/*", "scripts/packetInspectorProxy.ts"] } From a57c9ebfab4add0173b4a496fd698091d9334758 Mon Sep 17 00:00:00 2001 From: Even Rognlien Date: Sun, 21 Jul 2024 16:32:11 +0200 Subject: [PATCH 11/12] Add more utils to API helper --- package-lock.json | 4 +- src/ApiHelper/FacilitiesHelper.ts | 112 ++++++++++++++++++++- src/ApiHelper/SimConnectApi.ts | 17 ++++ src/ApiHelper/SimulationVariablesHelper.ts | 63 ++++++------ src/ApiHelper/index.ts | 2 +- src/ApiHelper/utils.ts | 12 +++ 6 files changed, 170 insertions(+), 40 deletions(-) create mode 100644 src/ApiHelper/SimConnectApi.ts diff --git a/package-lock.json b/package-lock.json index c697e07..63a95ae 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "node-simconnect", - "version": "3.6.1", + "version": "4.0.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "node-simconnect", - "version": "3.6.1", + "version": "4.0.0", "license": "LGPL-3.0-or-later", "dependencies": { "@types/node": "*", diff --git a/src/ApiHelper/FacilitiesHelper.ts b/src/ApiHelper/FacilitiesHelper.ts index 1b25c1d..e2aa6db 100644 --- a/src/ApiHelper/FacilitiesHelper.ts +++ b/src/ApiHelper/FacilitiesHelper.ts @@ -1,12 +1,21 @@ import { BaseHelper } from './BaseHelper'; import { SimConnectConnection } from '../SimConnectConnection'; import { SimConnectDataType } from '../enums/SimConnectDataType'; -import { JavascriptDataType, readSimConnectValue } from './utils'; +import { FacilityReturnType, JavascriptDataType, readSimConnectValue } from './utils'; import { FacilityDataType } from '../enums/FacilityDataType'; import { RawBuffer } from '../RawBuffer'; import { IcaoType } from '../dto'; import { SimConnectError } from './SimulationVariablesHelper'; import { SimConnectException } from '../enums/SimConnectException'; +import { FacilityListType } from '../enums'; +import { + RecvAirportList, + RecvFacilityData, + RecvFacilityDataEnd, + RecvNDBList, + RecvVORList, + RecvWaypointList, +} from '../recv'; export class FacilitiesHelper extends BaseHelper { private _nextFacilityDefinition: number; @@ -19,6 +28,93 @@ export class FacilitiesHelper extends BaseHelper { this._nextRequestId = 0; } + public async listAll( + facilityListType: T, + closestOnly: boolean = true + ): Promise { + return new Promise((resolve, reject) => { + const requestId = this._nextRequestId++; + const result: FacilityReturnType[T][] = []; + + const removeListener = this._handle.off; + + const sendId = closestOnly + ? this._handle.requestFacilitiesListEx1(facilityListType, requestId) + : this._handle.requestFacilitiesList(facilityListType, requestId); + + this._checkForException(sendId, err => { + reject( + Error( + `Failed to get facility list for type ${FacilityListType[facilityListType]}: ${SimConnectException[err]}` + ) + ); + }); + + function processAirportListChunk({ + requestID, + airports, + entryNumber, + outOf, + }: RecvAirportList) { + if (requestID === requestId) { + result.push(...(airports as FacilityReturnType[T][])); + if (entryNumber === outOf - 1) { + removeListener('airportList', processAirportListChunk); + resolve(result); + } + } + } + + function processVorListChunk({ requestID, vors, entryNumber, outOf }: RecvVORList) { + if (requestID === requestId) { + result.push(...(vors as FacilityReturnType[T][])); + if (entryNumber === outOf - 1) { + removeListener('vorList', processVorListChunk); + resolve(result); + } + } + } + + function processNdbListChunk({ requestID, ndbs, entryNumber, outOf }: RecvNDBList) { + if (requestID === requestId) { + result.push(...(ndbs as FacilityReturnType[T][])); + if (entryNumber === outOf - 1) { + removeListener('ndbList', processNdbListChunk); + resolve(result); + } + } + } + + function processWaypointListChunk({ + requestID, + waypoints, + entryNumber, + outOf, + }: RecvWaypointList) { + if (requestID === requestId) { + result.push(...(waypoints as FacilityReturnType[T][])); + if (entryNumber === outOf - 1) { + removeListener('waypointList', processWaypointListChunk); + resolve(result); + } + } + } + + if (facilityListType === FacilityListType.AIRPORT) { + this._handle.on('airportList', processAirportListChunk); + } + if (facilityListType === FacilityListType.VOR) { + this._handle.on('vorList', processVorListChunk); + } + if (facilityListType === FacilityListType.NDB) { + this._handle.on('ndbList', processNdbListChunk); + } + if (facilityListType === FacilityListType.WAYPOINT) { + this._handle.on('waypointList', processWaypointListChunk); + } + }); + } + /** * @param icao * @param facilityDefinition @@ -96,6 +192,8 @@ export class FacilitiesHelper extends BaseHelper { return new Promise>((resolve, reject) => { const defineId = this._nextFacilityDefinition++; const requestId = this._nextRequestId++; + const removeListener = this._handle.off; + this._registerFacilityDefinitionRecursively( defineId, { @@ -126,7 +224,7 @@ export class FacilitiesHelper extends BaseHelper { let output = {} as FacilityOutput; - this._handle.on('facilityData', recvFacilityData => { + function handleFacilityData(recvFacilityData: RecvFacilityData) { if (recvFacilityData.userRequestId === requestId) { const propName = FacilityDataType[recvFacilityData.type]; @@ -147,13 +245,17 @@ export class FacilitiesHelper extends BaseHelper { }; } } - }); + } - this._handle.on('facilityDataEnd', recvFacilityDataEnd => { + function handleEndOfFacilityData(recvFacilityDataEnd: RecvFacilityDataEnd) { if (recvFacilityDataEnd.userRequestId === requestId) { + removeListener('facilityData', handleFacilityData); resolve(output); } - }); + } + + this._handle.on('facilityData', handleFacilityData); + this._handle.once('facilityDataEnd', handleEndOfFacilityData); }); } diff --git a/src/ApiHelper/SimConnectApi.ts b/src/ApiHelper/SimConnectApi.ts new file mode 100644 index 0000000..80fd2b5 --- /dev/null +++ b/src/ApiHelper/SimConnectApi.ts @@ -0,0 +1,17 @@ +import { ConnectionOptions, FlightSimulatorApi, open, Protocol } from '..'; + +export class SimConnectApi { + appName: string; + + minimumCompatability: Protocol; + + constructor(appName: string, minimumCompatability: Protocol) { + this.appName = appName; + this.minimumCompatability = minimumCompatability; + } + + connect = async (connectionOptions?: ConnectionOptions) => { + const res = await open(this.appName, this.minimumCompatability, connectionOptions); + return new FlightSimulatorApi(res.handle); + }; +} diff --git a/src/ApiHelper/SimulationVariablesHelper.ts b/src/ApiHelper/SimulationVariablesHelper.ts index cb8dd1f..f472ea0 100644 --- a/src/ApiHelper/SimulationVariablesHelper.ts +++ b/src/ApiHelper/SimulationVariablesHelper.ts @@ -27,14 +27,6 @@ type CustomSimulationVariableRequest = { epsilon?: number; }; -/** - * A callback for when subscription data is received - */ -export type SimvarCallback = ( - err: SimConnectError | null, - data: VariablesResponse | null -) => void; - /** * The output object structure when requesting multiple simulation variables */ @@ -181,16 +173,16 @@ class SimulationVariablesHelper extends BaseHelper { /** * Continuously read a set of simulation variables - * @param simulationVariables The variables to monitor - * @param callback Called when the variables change + * @param simulationVariables The variables to watch + * @param onData Called when the variables change * @param options Additional options * @param options.onlyOnChange If the callback should trigger only when a variable changes * @param options.simObjectId Defaults to the user's aircraft * @param {SimConnectPeriod} options.interval Defaults to SimConnectPeriod.SIM_FRAME */ - monitor( + watch( simulationVariables: T[], - callback: SimvarCallback, + onData: (simvars: VariablesResponse) => void, options?: { onlyOnChange?: boolean; simObjectId?: number; @@ -210,8 +202,13 @@ class SimulationVariablesHelper extends BaseHelper { flags: options?.onlyOnChange ? DataRequestFlag.DATA_REQUEST_FLAG_CHANGED : 0, errorHandler: err => { hasFailed = true; - callback(err, null); this._handle.clearDataDefinition(sub.defineId); + + const simvarNames = simulationVariableRequests.map(varReq => varReq.name); + + throw new Error( + `SimConnect exception (${SimConnectException[err.exception]}) was thrown when trying to watch the following simvars: ${simvarNames}` + ); }, }); @@ -221,8 +218,7 @@ class SimulationVariablesHelper extends BaseHelper { sub.requestId === recvSimObjectData.requestID && sub.defineId === recvSimObjectData.defineID ) { - callback( - null, + onData( extractVariablesFromBuffer( simulationVariableRequests, recvSimObjectData.data @@ -234,24 +230,30 @@ class SimulationVariablesHelper extends BaseHelper { /** * Read simulation variables for a certain object type - * @param type The type of object to monitor + * @param simobjectType The type of object to watch * @param radiusMeters Radius from user's aircraft - * @param simulationVariables The variables to monitor - * @param callback Called when the variables change + * @param simulationVariables The variables to watch + * @param onData Called when the variables change */ - monitorObjects( - type: SimObjectType, + watchObjects( + simobjectType: SimObjectType, radiusMeters: number, simulationVariables: T[], - callback: SimvarCallback + onData: (simvars: VariablesResponse) => void ) { + const simulationVariableRequests = simulationVariables.map( + toStandardizedSimulationVariableRequest + ); const sub = this._makeSubscriptionByType({ - simulationVariableRequests: simulationVariables.map( - toStandardizedSimulationVariableRequest - ), + simulationVariableRequests, radiusMeters, - type, - errorHandler: err => callback(err, null), + simobjectType, + errorHandler: err => { + const simvarNames = simulationVariableRequests.map(varReq => varReq.name); + throw new Error( + `SimConnect exception (${SimConnectException[err.exception]}) was thrown when trying to watch the following simvars for object type ${SimObjectType[simobjectType]}: ${simvarNames}` + ); + }, }); this._handle.on('simObjectDataByType', recvSimObjectData => { @@ -259,10 +261,7 @@ class SimulationVariablesHelper extends BaseHelper { sub.requestId === recvSimObjectData.requestID && sub.defineId === recvSimObjectData.defineID ) { - callback( - null, - extractVariablesFromBuffer(simulationVariables, recvSimObjectData.data) - ); + onData(extractVariablesFromBuffer(simulationVariables, recvSimObjectData.data)); // this._handle.clearDataDefinition(sub.defineId); } }); @@ -302,7 +301,7 @@ class SimulationVariablesHelper extends BaseHelper { private _makeSubscriptionByType(params: { simulationVariableRequests: CustomSimulationVariableRequest[]; radiusMeters: number; - type: SimObjectType; + simobjectType: SimObjectType; errorHandler: (error: SimConnectError) => void; }): { defineId: number; requestId: number } { const requestId = this._nextDataRequestId++; @@ -316,7 +315,7 @@ class SimulationVariablesHelper extends BaseHelper { requestId, defineId, params.radiusMeters, - params.type + params.simobjectType ); this._checkForException(sendId, ex => diff --git a/src/ApiHelper/index.ts b/src/ApiHelper/index.ts index 6015769..25a6e3b 100644 --- a/src/ApiHelper/index.ts +++ b/src/ApiHelper/index.ts @@ -3,7 +3,7 @@ import { SimulationVariablesHelper } from './SimulationVariablesHelper'; import { SystemEventsHelper } from './SystemEventsHelper'; import { FacilitiesHelper } from './FacilitiesHelper'; -export class ApiHelper { +export class FlightSimulatorApi { simulationVariables: SimulationVariablesHelper; systemEvents: SystemEventsHelper; diff --git a/src/ApiHelper/utils.ts b/src/ApiHelper/utils.ts index 36b2eb1..ebb71f7 100644 --- a/src/ApiHelper/utils.ts +++ b/src/ApiHelper/utils.ts @@ -12,6 +12,8 @@ import { Waypoint, XYZ, } from '../dto'; +import { FacilityListType } from '../enums'; +import { FacilityAirport, FacilityNDB, FacilityVOR, FacilityWaypoint } from '../datastructures'; export function readSimConnectValue( rawBuffer: RawBuffer, @@ -129,3 +131,13 @@ export type JavascriptDataType = { [SimConnectDataType.MAX]: undefined; }[T]; }; + +export type FacilityReturnType = { + [T in FacilityListType]: { + [FacilityListType.NDB]: FacilityNDB; + [FacilityListType.VOR]: FacilityVOR; + [FacilityListType.AIRPORT]: FacilityAirport; + [FacilityListType.WAYPOINT]: FacilityWaypoint; + [FacilityListType.COUNT]: undefined; + }[T]; +}; From 751b2251e400b1b622287e7d2815bbe7083843da Mon Sep 17 00:00:00 2001 From: Even Rognlien Date: Mon, 29 Jul 2024 23:14:20 +0200 Subject: [PATCH 12/12] Add script for scraping simvars from online docs --- generated/simvars.ts | 5422 ++++++++++++------------ package.json | 6 +- src/ApiHelper/scripts/scrapeSimvars.ts | 143 + 3 files changed, 2974 insertions(+), 2597 deletions(-) create mode 100644 src/ApiHelper/scripts/scrapeSimvars.ts diff --git a/generated/simvars.ts b/generated/simvars.ts index 0fba4ea..ecdb365 100644 --- a/generated/simvars.ts +++ b/generated/simvars.ts @@ -1,4 +1,4 @@ -import { SimConnectDataType } from '../src/enums/SimConnectDataType'; +import { SimConnectDataType } from '../dist'; export type PredefinedVariable = { name: string; @@ -8,8525 +8,8741 @@ export type PredefinedVariable = { }; export const simvarPredefinitions = { - /** Currently not used within the simulation. */ - AUTOPILOT_AIRSPEED_ACQUISITION: { + /** Currently not used within the simulation. */ + 'AUTOPILOT AIRSPEED ACQUISITION': { name: 'AUTOPILOT AIRSPEED ACQUISITION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** returns whether airspeed hold is active (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_AIRSPEED_HOLD: { + 'AUTOPILOT AIRSPEED HOLD': { name: 'AUTOPILOT AIRSPEED HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Currently not used within the simulation. */ - AUTOPILOT_AIRSPEED_HOLD_CURRENT: { + /** Currently not used within the simulation. */ + 'AUTOPILOT AIRSPEED HOLD CURRENT': { name: 'AUTOPILOT AIRSPEED HOLD CURRENT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns the target holding airspeed for the autopilot. */ - AUTOPILOT_AIRSPEED_HOLD_VAR: { + 'AUTOPILOT AIRSPEED HOLD VAR': { name: 'AUTOPILOT AIRSPEED HOLD VAR', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the maximum calculated airspeed (kcas) limit set for the autopilot. */ - AUTOPILOT_AIRSPEED_MAX_CALCULATED: { + /** Returns the maximum calculated airspeed (kcas) limit set for the autopilot. */ + 'AUTOPILOT AIRSPEED MAX CALCULATED': { name: 'AUTOPILOT AIRSPEED MAX CALCULATED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the minimum calculated airspeed (kcas) limit set for the autopilot. */ - AUTOPILOT_AIRSPEED_MIN_CALCULATED: { + /** Returns the minimum calculated airspeed (kcas) limit set for the autopilot. */ + 'AUTOPILOT AIRSPEED MIN CALCULATED': { name: 'AUTOPILOT AIRSPEED MIN CALCULATED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** If enabled the Autopilot will use the Radio Altitude rather than the Indicated Altitude. */ - AUTOPILOT_ALT_RADIO_MODE: { + 'AUTOPILOT ALT RADIO MODE': { name: 'AUTOPILOT ALT RADIO MODE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the autopilot is in Altitude Arm mode (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_ALTITUDE_ARM: { + 'AUTOPILOT ALTITUDE ARM': { name: 'AUTOPILOT ALTITUDE ARM', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Altitude hold active */ - AUTOPILOT_ALTITUDE_LOCK: { + 'AUTOPILOT ALTITUDE LOCK': { name: 'AUTOPILOT ALTITUDE LOCK', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Set or get the slot index which the altitude hold mode will track when captured. See alt_mode_slot_index for more information. */ - AUTOPILOT_ALTITUDE_LOCK_VAR: { + /** Set or get the slot index which the altitude hold mode will track when captured. See alt_mode_slot_index for more information. */ + 'AUTOPILOT ALTITUDE LOCK VAR': { name: 'AUTOPILOT ALTITUDE LOCK VAR', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Whether or not the autopilot altitude is manually tunable or not. */ - AUTOPILOT_ALTITUDE_MANUALLY_TUNABLE: { + 'AUTOPILOT ALTITUDE MANUALLY TUNABLE': { name: 'AUTOPILOT ALTITUDE MANUALLY TUNABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Index of the slot that the autopilot will use for the altitude reference. Note that there are 3 slots (1, 2, 3) that you can set/get normally, however you can also target slot index 0. Writing to slot 0 will overwrite all other slots with the slot 0 value, and by default the autopilot will follow slot 0 if you have not selected any slot index. - See alt_mode_slot_index for more information. */ - AUTOPILOT_ALTITUDE_SLOT_INDEX: { + /** +

Index of the slot that the autopilot will use for the altitude reference. Note that there are 3 slots (1, 2, 3) that you can set/get normally, however you can also target slot index 0. Writing to slot 0 will overwrite all other slots with the slot 0 value, and by default the autopilot will follow slot 0 if you have not selected any slot index.

+

See alt_mode_slot_index for more information.

+ */ + 'AUTOPILOT ALTITUDE SLOT INDEX': { name: 'AUTOPILOT ALTITUDE SLOT INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** When true, the autopilot is currently flying the approach Flight Plan (the last legs). */ - AUTOPILOT_APPROACH_ACTIVE: { + 'AUTOPILOT APPROACH ACTIVE': { name: 'AUTOPILOT APPROACH ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, + /** The stored COM 1/2/3 frequency value. */ + '': { + name: '', + units: 'Frequency BCD16', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, /** Returns true when the autopilot is active on the approach, once it reaches the adequate condition (in most cases, once it reaches the second-last waypoint of the flightplan). */ - AUTOPILOT_APPROACH_ARM: { + 'AUTOPILOT APPROACH ARM': { name: 'AUTOPILOT APPROACH ARM', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns true when the lateral NAV mode is engaged and the angular deviation with the current tuned navigation frequency is less than 5°. */ - AUTOPILOT_APPROACH_CAPTURED: { + 'AUTOPILOT APPROACH CAPTURED': { name: 'AUTOPILOT APPROACH CAPTURED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether pproach mode is active (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_APPROACH_HOLD: { + 'AUTOPILOT APPROACH HOLD': { name: 'AUTOPILOT APPROACH HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns true if the current approach is using a localizer. */ - AUTOPILOT_APPROACH_IS_LOCALIZER: { + 'AUTOPILOT APPROACH IS LOCALIZER': { name: 'AUTOPILOT APPROACH IS LOCALIZER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Attitude hold active */ - AUTOPILOT_ATTITUDE_HOLD: { + 'AUTOPILOT ATTITUDE HOLD': { name: 'AUTOPILOT ATTITUDE HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Available flag */ - AUTOPILOT_AVAILABLE: { + 'AUTOPILOT AVAILABLE': { name: 'AUTOPILOT AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the autopilot has active managed avionics (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_AVIONICS_MANAGED: { + 'AUTOPILOT AVIONICS MANAGED': { name: 'AUTOPILOT AVIONICS MANAGED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the autopilot back course mode is active (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_BACKCOURSE_HOLD: { + 'AUTOPILOT BACKCOURSE HOLD': { name: 'AUTOPILOT BACKCOURSE HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the autopilot bank hold mode is active (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_BANK_HOLD: { + 'AUTOPILOT BANK HOLD': { name: 'AUTOPILOT BANK HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The current bank-hold bank reference. - Note that if you set this, the next frame the value will be overwritten by the engine, so you may need to write to this every game frame to ensure it maintains the required value. */ - AUTOPILOT_BANK_HOLD_REF: { + /** +

The current bank-hold bank reference.

+

Note that if you set this, the next frame the value will be overwritten by the engine, so you may need to write to this every game frame to ensure it maintains the required value.

+ */ + 'AUTOPILOT BANK HOLD REF': { name: 'AUTOPILOT BANK HOLD REF', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Currently not used within the simulation. */ - AUTOPILOT_CRUISE_SPEED_HOLD: { + /** Currently not used within the simulation. */ + 'AUTOPILOT CRUISE SPEED HOLD': { name: 'AUTOPILOT CRUISE SPEED HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The current default pitch mode of the autopilot as configured in the plane configuration with the parameter default_pitch_mode. */ - AUTOPILOT_DEFAULT_PITCH_MODE: { + /** +

The current default pitch mode of the autopilot as configured in the plane configuration with the parameter default_pitch_mode.

+ */ + 'AUTOPILOT DEFAULT PITCH MODE': { name: 'AUTOPILOT DEFAULT PITCH MODE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** The current default roll mode of the autopilot as configured in the plane configuration with the parameter default_bank_mode. */ - AUTOPILOT_DEFAULT_ROLL_MODE: { + /** The current default roll mode of the autopilot as configured in the plane configuration with the parameter default_bank_mode. */ + 'AUTOPILOT DEFAULT ROLL MODE': { name: 'AUTOPILOT DEFAULT ROLL MODE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the autopilot has been disengaged (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_DISENGAGED: { + 'AUTOPILOT DISENGAGED': { name: 'AUTOPILOT DISENGAGED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Flight director active */ - AUTOPILOT_FLIGHT_DIRECTOR_ACTIVE: { + 'AUTOPILOT FLIGHT DIRECTOR ACTIVE': { name: 'AUTOPILOT FLIGHT DIRECTOR ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Reference bank angle */ - AUTOPILOT_FLIGHT_DIRECTOR_BANK: { + 'AUTOPILOT FLIGHT DIRECTOR BANK': { name: 'AUTOPILOT FLIGHT DIRECTOR BANK', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Raw reference bank angle */ - AUTOPILOT_FLIGHT_DIRECTOR_BANK_EX1: { + 'AUTOPILOT FLIGHT DIRECTOR BANK EX1': { name: 'AUTOPILOT FLIGHT DIRECTOR BANK EX1', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Reference pitch angle */ - AUTOPILOT_FLIGHT_DIRECTOR_PITCH: { + 'AUTOPILOT FLIGHT DIRECTOR PITCH': { name: 'AUTOPILOT FLIGHT DIRECTOR PITCH', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Raw reference pitch angle */ - AUTOPILOT_FLIGHT_DIRECTOR_PITCH_EX1: { + 'AUTOPILOT FLIGHT DIRECTOR PITCH EX1': { name: 'AUTOPILOT FLIGHT DIRECTOR PITCH EX1', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Boolean, toggles the autopilot Flight Level Change mode */ - AUTOPILOT_FLIGHT_LEVEL_CHANGE: { + 'AUTOPILOT FLIGHT LEVEL CHANGE': { name: 'AUTOPILOT FLIGHT LEVEL CHANGE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** When true, the autopilot is receiving a signal from the runway beacon and is following the slope to reach the ground. */ - AUTOPILOT_GLIDESLOPE_ACTIVE: { + 'AUTOPILOT GLIDESLOPE ACTIVE': { name: 'AUTOPILOT GLIDESLOPE ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns true when the autopilot is active on the glide slope. */ - AUTOPILOT_GLIDESLOPE_ARM: { + 'AUTOPILOT GLIDESLOPE ARM': { name: 'AUTOPILOT GLIDESLOPE ARM', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the autopilot glidslope hold is active (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_GLIDESLOPE_HOLD: { + 'AUTOPILOT GLIDESLOPE HOLD': { name: 'AUTOPILOT GLIDESLOPE HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the autopilot heading lock is enabled (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_HEADING_LOCK: { + 'AUTOPILOT HEADING LOCK': { name: 'AUTOPILOT HEADING LOCK', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Specifies / Returns the locked in heading for the autopilot. */ - AUTOPILOT_HEADING_LOCK_DIR: { + /** Specifies / Returns the locked in heading for the autopilot.  */ + 'AUTOPILOT HEADING LOCK DIR': { name: 'AUTOPILOT HEADING LOCK DIR', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Whether or not the autopilot heading is manually tunable or not. */ - AUTOPILOT_HEADING_MANUALLY_TUNABLE: { + 'AUTOPILOT HEADING MANUALLY TUNABLE': { name: 'AUTOPILOT HEADING MANUALLY TUNABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Index of the slot that the autopilot will use for the heading reference. Note that there are 3 slots (1, 2, 3) that you can set/get normally, however you can also target slot index 0. Writing to slot 0 will overwrite all other slots with the slot 0 value, and by default the autopilot will follow slot 0 if you have not selected any slot index. */ - AUTOPILOT_HEADING_SLOT_INDEX: { + 'AUTOPILOT HEADING SLOT INDEX': { name: 'AUTOPILOT HEADING SLOT INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Mach hold active */ - AUTOPILOT_MACH_HOLD: { + 'AUTOPILOT MACH HOLD': { name: 'AUTOPILOT MACH HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Returns the target holding mach airspeed -for the autopilot. */ - AUTOPILOT_MACH_HOLD_VAR: { + /** Returns the target holding mach airspeed for the autopilot. */ + 'AUTOPILOT MACH HOLD VAR': { name: 'AUTOPILOT MACH HOLD VAR', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Currently not used within the simulation. */ - AUTOPILOT_MANAGED_INDEX: { + /** Currently not used within the simulation. */ + 'AUTOPILOT MANAGED INDEX': { name: 'AUTOPILOT MANAGED INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns whether the managed speed is in mach (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_MANAGED_SPEED_IN_MACH: { + 'AUTOPILOT MANAGED SPEED IN MACH': { name: 'AUTOPILOT MANAGED SPEED IN MACH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the autopilot managed throttle is active (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_MANAGED_THROTTLE_ACTIVE: { + 'AUTOPILOT MANAGED THROTTLE ACTIVE': { name: 'AUTOPILOT MANAGED THROTTLE ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** On/off flag */ - AUTOPILOT_MASTER: { + 'AUTOPILOT MASTER': { name: 'AUTOPILOT MASTER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns the maximum banking angle for the autopilot, in radians. */ - AUTOPILOT_MAX_BANK: { + 'AUTOPILOT MAX BANK': { name: 'AUTOPILOT MAX BANK', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns the index of the current maximum bank setting of the autopilot. */ - AUTOPILOT_MAX_BANK_ID: { + 'AUTOPILOT MAX BANK ID': { name: 'AUTOPILOT MAX BANK ID', units: 'Integer', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Currently not used within the simulation. */ - AUTOPILOT_MAX_SPEED_HOLD: { + /** Currently not used within the simulation. */ + 'AUTOPILOT MAX SPEED HOLD': { name: 'AUTOPILOT MAX SPEED HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns TRUE (1) if the autopilot Nav1 lock is applied, or 0 (FALSE) otherwise. */ - AUTOPILOT_NAV1_LOCK: { + 'AUTOPILOT NAV1 LOCK': { name: 'AUTOPILOT NAV1 LOCK', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Index of Nav radio selected */ - AUTOPILOT_NAV_SELECTED: { + 'AUTOPILOT NAV SELECTED': { name: 'AUTOPILOT NAV SELECTED', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Set to True if the autopilot pitch hold has is engaged. */ - AUTOPILOT_PITCH_HOLD: { + 'AUTOPILOT PITCH HOLD': { name: 'AUTOPILOT PITCH HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns the current autotpilot reference pitch. */ - AUTOPILOT_PITCH_HOLD_REF: { + 'AUTOPILOT PITCH HOLD REF': { name: 'AUTOPILOT PITCH HOLD REF', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if autopilot rpm hold applied */ - AUTOPILOT_RPM_HOLD: { + 'AUTOPILOT RPM HOLD': { name: 'AUTOPILOT RPM HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Selected rpm */ - AUTOPILOT_RPM_HOLD_VAR: { + 'AUTOPILOT RPM HOLD VAR': { name: 'AUTOPILOT RPM HOLD VAR', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Index of the slot that the autopilot will use for the RPM reference. Note that there are 3 slots (1, 2, 3) that you can set/get normally, however you can also target slot index 0. Writing to slot 0 will overwrite all other slots with the slot 0 value, and by default the autopilot will follow slot 0 if you have not selected any slot index. */ - AUTOPILOT_RPM_SLOT_INDEX: { + 'AUTOPILOT RPM SLOT INDEX': { name: 'AUTOPILOT RPM SLOT INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Currently not used within the simulation. */ - AUTOPILOT_SPEED_SETTING: { + /** Currently not used within the simulation. */ + 'AUTOPILOT SPEED SETTING': { name: 'AUTOPILOT SPEED SETTING', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Index of the managed references */ - AUTOPILOT_SPEED_SLOT_INDEX: { + 'AUTOPILOT SPEED SLOT INDEX': { name: 'AUTOPILOT SPEED SLOT INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Takeoff / Go Around power mode active */ - AUTOPILOT_TAKEOFF_POWER_ACTIVE: { + 'AUTOPILOT TAKEOFF POWER ACTIVE': { name: 'AUTOPILOT TAKEOFF POWER ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the autopilot auto-throttle is armed (1, TRUE) or not (0, FALSE). */ - AUTOPILOT_THROTTLE_ARM: { + 'AUTOPILOT THROTTLE ARM': { name: 'AUTOPILOT THROTTLE ARM', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** This can be used to set/get the thrust lever position for autopilot maximum thrust. */ - AUTOPILOT_THROTTLE_MAX_THRUST: { + 'AUTOPILOT THROTTLE MAX THRUST': { name: 'AUTOPILOT THROTTLE MAX THRUST', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** True if autopilot vertical hold applied */ - AUTOPILOT_VERTICAL_HOLD: { + 'AUTOPILOT VERTICAL HOLD': { name: 'AUTOPILOT VERTICAL HOLD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Selected vertical speed */ - AUTOPILOT_VERTICAL_HOLD_VAR: { + 'AUTOPILOT VERTICAL HOLD VAR': { name: 'AUTOPILOT VERTICAL HOLD VAR', units: 'Feet (ft)/minute', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Index of the slot that the autopilot will use for the VS reference. Note that there are 3 slots (1, 2, 3) that you can set/get normally, however you can also target slot index 0. Writing to slot 0 will overwrite all other slots with the slot 0 value, and by default the autopilot will follow slot 0 if you have not selected any slot index. */ - AUTOPILOT_VS_SLOT_INDEX: { + 'AUTOPILOT VS SLOT INDEX': { name: 'AUTOPILOT VS SLOT INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Wing leveler active */ - AUTOPILOT_WING_LEVELER: { + 'AUTOPILOT WING LEVELER': { name: 'AUTOPILOT WING LEVELER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Yaw damper active */ - AUTOPILOT_YAW_DAMPER: { + 'AUTOPILOT YAW DAMPER': { name: 'AUTOPILOT YAW DAMPER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether landing assistance has been enabled or not. */ - ASSISTANCE_LANDING_ENABLED: { + 'ASSISTANCE LANDING ENABLED': { name: 'ASSISTANCE LANDING ENABLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether takeoff assistance has been enabled or not. */ - ASSISTANCE_TAKEOFF_ENABLED: { + 'ASSISTANCE TAKEOFF ENABLED': { name: 'ASSISTANCE TAKEOFF ENABLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The current state of the AI anti-stall system. */ - AI_ANTISTALL_STATE: { + 'AI ANTISTALL STATE': { name: 'AI ANTISTALL STATE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the AI auto-trim system is enabled or not. */ - AI_AUTOTRIM_ACTIVE: { + 'AI AUTOTRIM ACTIVE': { name: 'AI AUTOTRIM ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the AI auto-trim system is enabled or not for AI controlled aircraft. */ - AI_AUTOTRIM_ACTIVE_AGAINST_PLAYER: { + 'AI AUTOTRIM ACTIVE AGAINST PLAYER': { name: 'AI AUTOTRIM ACTIVE AGAINST PLAYER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the AI control system is enabled or not. */ - AI_CONTROLS: { + 'AI CONTROLS': { name: 'AI CONTROLS', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether the AI cursor mode is active or not. */ - AI_CURSOR_MODE_ACTIVE: { + 'AI CURSOR MODE ACTIVE': { name: 'AI CURSOR MODE ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** AI reference pitch reference bars */ - ATTITUDE_BARS_POSITION: { + 'ATTITUDE BARS POSITION': { name: 'ATTITUDE BARS POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** AI caged state */ - ATTITUDE_CAGE: { + 'ATTITUDE CAGE': { name: 'ATTITUDE CAGE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** AI bank indication */ - ATTITUDE_INDICATOR_BANK_DEGREES: { + 'ATTITUDE INDICATOR BANK DEGREES': { name: 'ATTITUDE INDICATOR BANK DEGREES', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** AI pitch indication */ - ATTITUDE_INDICATOR_PITCH_DEGREES: { + 'ATTITUDE INDICATOR PITCH DEGREES': { name: 'ATTITUDE INDICATOR PITCH DEGREES', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns whether the AI control system is active or not. */ - DELEGATE_CONTROLS_TO_AI: { + 'DELEGATE CONTROLS TO AI': { name: 'DELEGATE CONTROLS TO AI', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** When set with any value this will cancel the current flight assistant destination. */ - FLY_ASSISTANT_CANCEL_DESTINATION: { + 'FLY ASSISTANT CANCEL DESTINATION': { name: 'FLY ASSISTANT CANCEL DESTINATION', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** When set with any value this will cancel the display of the current flight assistant destination. */ - FLY_ASSISTANT_CANCEL_DESTINATION_DISPLAY: { + 'FLY ASSISTANT CANCEL DESTINATION DISPLAY': { name: 'FLY ASSISTANT CANCEL DESTINATION DISPLAY', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Returns true when the copilot AI control is active and therefore COM AI is locked on active too. */ - FLY_ASSISTANT_COM_AI_LOCKED: { + 'FLY ASSISTANT COM AI LOCKED': { name: 'FLY ASSISTANT COM AI LOCKED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Returns true when a destination has been set in the flight assistant. */ - FLY_ASSISTANT_HAVE_DESTINATION: { + /** Returns true when a destination has been set in the flight assistant. */ + 'FLY ASSISTANT HAVE DESTINATION': { name: 'FLY ASSISTANT HAVE DESTINATION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Returns the POH range or an estimated value for this speed. */ - FLY_ASSISTANT_LANDING_SPEED: { + /** Returns the POH range or an estimated value for this speed. */ + 'FLY ASSISTANT LANDING SPEED': { name: 'FLY ASSISTANT LANDING SPEED', - units: 'String', + units: '', dataType: SimConnectDataType.STRING32, settable: false, }, /** Returns the display mode of the speed, CSS side (only STALL SPEED is working and will turn red when below). */ - FLY_ASSISTANT_LANDING_SPEED_DISPLAY_MODE: { + 'FLY ASSISTANT LANDING SPEED DISPLAY MODE': { name: 'FLY ASSISTANT LANDING SPEED DISPLAY MODE', - units: 'String', + units: '', dataType: SimConnectDataType.STRING32, settable: false, }, /** Selected category */ - FLY_ASSISTANT_NEAREST_CATEGORY: { + 'FLY ASSISTANT NEAREST CATEGORY': { name: 'FLY ASSISTANT NEAREST CATEGORY', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Number of elements in this category */ - FLY_ASSISTANT_NEAREST_COUNT: { + 'FLY ASSISTANT NEAREST COUNT': { name: 'FLY ASSISTANT NEAREST COUNT', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Currently not used within the simulation. */ - FLY_ASSISTANT_NEAREST_METADATA: { + /** Currently not used within the simulation. */ + 'FLY ASSISTANT NEAREST METADATA': { name: 'FLY ASSISTANT NEAREST METADATA', units: '-', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns the name of the element at the specified index. */ - FLY_ASSISTANT_NEAREST_NAME: { + 'FLY ASSISTANT NEAREST NAME': { name: 'FLY ASSISTANT NEAREST NAME', - units: 'String', + units: '', dataType: SimConnectDataType.STRING256, settable: false, }, /** Returns the index of the currently selected element. */ - FLY_ASSISTANT_NEAREST_SELECTED: { + 'FLY ASSISTANT NEAREST SELECTED': { name: 'FLY ASSISTANT NEAREST SELECTED', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Returns true when both ribbon assistances are active (taxi and landing), and can also be used to set them. */ - FLY_ASSISTANT_RIBBONS_ACTIVE: { + 'FLY ASSISTANT RIBBONS ACTIVE': { name: 'FLY ASSISTANT RIBBONS ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** When set with any value, it will set the selected element as the current destination. */ - FLY_ASSISTANT_SET_AS_DESTINATION: { + 'FLY ASSISTANT SET AS DESTINATION': { name: 'FLY ASSISTANT SET AS DESTINATION', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Returns the flight assistant stall speed. */ - FLY_ASSISTANT_STALL_SPEED: { + 'FLY ASSISTANT STALL SPEED': { name: 'FLY ASSISTANT STALL SPEED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Returns the flight assistant stall speed display mode. */ - FLY_ASSISTANT_STALL_SPEED_DISPLAY_MODE: { + 'FLY ASSISTANT STALL SPEED DISPLAY MODE': { name: 'FLY ASSISTANT STALL SPEED DISPLAY MODE', - units: 'String', + units: '', dataType: SimConnectDataType.STRING32, settable: false, }, /** Returns the flight assistant takeoff speed. */ - FLY_ASSISTANT_TAKEOFF_SPEED: { + 'FLY ASSISTANT TAKEOFF SPEED': { name: 'FLY ASSISTANT TAKEOFF SPEED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Returns the flight assistant takeoff speed display mode. */ - FLY_ASSISTANT_TAKEOFF_SPEED_DISPLAY_MODE: { + 'FLY ASSISTANT TAKEOFF SPEED DISPLAY MODE': { name: 'FLY ASSISTANT TAKEOFF SPEED DISPLAY MODE', - units: 'String', + units: '', dataType: SimConnectDataType.STRING32, settable: false, }, /** Can be set to override the estimated takeoff speed */ - FLY_ASSISTANT_TAKEOFF_SPEED_ESTIMATED: { + 'FLY ASSISTANT TAKEOFF SPEED ESTIMATED': { name: 'FLY ASSISTANT TAKEOFF SPEED ESTIMATED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** True if antiskid brakes active. This can be set using the AntiSkidActive parameter. */ - ANTISKID_BRAKES_ACTIVE: { + /** True if antiskid brakes active. This can be set using the AntiSkidActive parameter. */ + 'ANTISKID BRAKES ACTIVE': { name: 'ANTISKID BRAKES ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not the AutoBrakes are currently active. */ - AUTOBRAKES_ACTIVE: { + 'AUTOBRAKES ACTIVE': { name: 'AUTOBRAKES ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Auto brake switch position */ - AUTO_BRAKE_SWITCH_CB: { + 'AUTO BRAKE SWITCH CB': { name: 'AUTO BRAKE SWITCH CB', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Brake dependent hydraulic pressure reading */ - BRAKE_DEPENDENT_HYDRAULIC_PRESSURE: { + 'BRAKE DEPENDENT HYDRAULIC PRESSURE': { name: 'BRAKE DEPENDENT HYDRAULIC PRESSURE', units: 'Pounds per square foot (psf)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Brake on indication */ - BRAKE_INDICATOR: { + 'BRAKE INDICATOR': { name: 'BRAKE INDICATOR', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent left brake. - Note that this SimVar no longer sets the right brake percent and simply triggers a brake pressure increase regardless of the value passed. */ - BRAKE_LEFT_POSITION: { + /** +

Percent left brake.

+

Note that this SimVar no longer sets the right brake percent and simply triggers a brake pressure increase regardless of the value passed.

+ */ + 'BRAKE LEFT POSITION': { name: 'BRAKE LEFT POSITION', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Triggers a brake pressure increase on the left brake regardless of the value passed. */ - BRAKE_LEFT_POSITION_EX1: { + 'BRAKE LEFT POSITION EX1': { name: 'BRAKE LEFT POSITION EX1', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Parking brake indicator */ - BRAKE_PARKING_INDICATOR: { + 'BRAKE PARKING INDICATOR': { name: 'BRAKE PARKING INDICATOR', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Gets the parking brake position - either on (true) or off (false). */ - BRAKE_PARKING_POSITION: { + /** +

Gets the parking brake position - either on (true) or off (false).

+ */ + 'BRAKE PARKING POSITION': { name: 'BRAKE PARKING POSITION', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Percent right brake. */ - BRAKE_RIGHT_POSITION: { + /** +

Percent right brake.

+ */ + 'BRAKE RIGHT POSITION': { name: 'BRAKE RIGHT POSITION', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Triggers a brake pressure increase on the right brake regardless of the value passed. */ - BRAKE_RIGHT_POSITION_EX1: { + 'BRAKE RIGHT POSITION EX1': { name: 'BRAKE RIGHT POSITION EX1', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Whether or not the rejected takeoff brakes are currently active. */ - REJECTED_TAKEOFF_BRAKES_ACTIVE: { + 'REJECTED TAKEOFF BRAKES ACTIVE': { name: 'REJECTED TAKEOFF BRAKES ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if toe brakes are available */ - TOE_BRAKES_AVAILABLE: { + 'TOE BRAKES AVAILABLE': { name: 'TOE BRAKES AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The percentage value representing the amount the contact point is compressed. Index is from 0-19. */ - 'CONTACT_POINT_COMPRESSION:index': { + 'CONTACT POINT COMPRESSION:index': { name: 'CONTACT POINT COMPRESSION:index', units: 'Position', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns true if the indexed contact point is on the ground, or will return false otherwise. Index is from 0 - 19. */ - 'CONTACT_POINT_IS_ON_GROUND:index': { + 'CONTACT POINT IS ON GROUND:index': { name: 'CONTACT POINT IS ON GROUND:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns true if the indexed contact point is skidding, or will return false otherwise. Index is from 0 - 19. */ - 'CONTACT_POINT_IS_SKIDDING:index': { + 'CONTACT POINT IS SKIDDING:index': { name: 'CONTACT POINT IS SKIDDING:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The currently extended position of the (retractable) contact point, expressed as a percentage. Index is from 0 - 19. */ - 'CONTACT_POINT_POSITION:index': { + 'CONTACT POINT POSITION:index': { name: 'CONTACT POINT POSITION:index', units: 'Position', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The skidding factor associated with the indexed contact point, from 0 to 1. Index is from 0 - 19. */ - 'CONTACT_POINT_SKIDDING_FACTOR:index': { + 'CONTACT POINT SKIDDING FACTOR:index': { name: 'CONTACT POINT SKIDDING FACTOR:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This returns the depth of the water for the indexed contact point. Index is from 0 - 19. */ - 'CONTACT_POINT_WATER_DEPTH:index': { + 'CONTACT POINT WATER DEPTH:index': { name: 'CONTACT POINT WATER DEPTH:index', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Aux wheel rotation angle (rotation around the axis for the wheel). */ - AUX_WHEEL_ROTATION_ANGLE: { + 'AUX WHEEL ROTATION ANGLE': { name: 'AUX WHEEL ROTATION ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Rpm of fourth set of gear wheels. */ - AUX_WHEEL_RPM: { + 'AUX WHEEL RPM': { name: 'AUX WHEEL RPM', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Center wheel rotation angle (rotation around the axis for the wheel). - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - CENTER_WHEEL_ROTATION_ANGLE: { + /** +

Center wheel rotation angle (rotation around the axis for the wheel).

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'CENTER WHEEL ROTATION ANGLE': { name: 'CENTER WHEEL ROTATION ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Center landing gear rpm. */ - CENTER_WHEEL_RPM: { + 'CENTER WHEEL RPM': { name: 'CENTER WHEEL RPM', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent indexed gear animation extended. NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'GEAR_ANIMATION_POSITION:index': { + /** Percent indexed gear animation extended. NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer. */ + 'GEAR ANIMATION POSITION:index': { name: 'GEAR ANIMATION POSITION:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent auxiliary gear extended. */ - GEAR_AUX_POSITION: { + 'GEAR AUX POSITION': { name: 'GEAR AUX POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Aux wheel angle, negative to the left, positive to the right. The aux wheel is the fourth set of landing gear, sometimes used on helicopters. */ - GEAR_AUX_STEER_ANGLE: { + 'GEAR AUX STEER ANGLE': { name: 'GEAR AUX STEER ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Aux steer angle as a percentage. */ - GEAR_AUX_STEER_ANGLE_PCT: { + 'GEAR AUX STEER ANGLE PCT': { name: 'GEAR AUX STEER ANGLE PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent center gear extended. */ - GEAR_CENTER_POSITION: { + 'GEAR CENTER POSITION': { name: 'GEAR CENTER POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Center wheel angle, negative to the left, positive to the right. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - GEAR_CENTER_STEER_ANGLE: { + /** +

Center wheel angle, negative to the left, positive to the right.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GEAR CENTER STEER ANGLE': { name: 'GEAR CENTER STEER ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Center steer angle as a percentage. */ - GEAR_CENTER_STEER_ANGLE_PCT: { + 'GEAR CENTER STEER ANGLE PCT': { name: 'GEAR CENTER STEER ANGLE PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if gear has been damaged by excessive speed. */ - GEAR_DAMAGE_BY_SPEED: { + 'GEAR DAMAGE BY SPEED': { name: 'GEAR DAMAGE BY SPEED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if gear emergency handle applied. */ - GEAR_EMERGENCY_HANDLE_POSITION: { + 'GEAR EMERGENCY HANDLE POSITION': { name: 'GEAR EMERGENCY HANDLE POSITION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The gear handle position, where 0 means the handle is retracted and 1 is the handle fully applied. */ - GEAR_HANDLE_POSITION: { + 'GEAR HANDLE POSITION': { name: 'GEAR HANDLE POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Gear hydraulic pressure. */ - GEAR_HYDRAULIC_PRESSURE: { + 'GEAR HYDRAULIC PRESSURE': { name: 'GEAR HYDRAULIC PRESSURE', units: 'Pound force per square foot (psf)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if the gear is on the ground. */ - 'GEAR_IS_ON_GROUND:index': { + 'GEAR IS ON GROUND:index': { name: 'GEAR IS ON GROUND:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the gear is skidding. */ - 'GEAR_IS_SKIDDING:index': { + 'GEAR IS SKIDDING:index': { name: 'GEAR IS SKIDDING:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Percent left gear extended. */ - GEAR_LEFT_POSITION: { + 'GEAR LEFT POSITION': { name: 'GEAR LEFT POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Left wheel angle, negative to the left, positive to the right. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - GEAR_LEFT_STEER_ANGLE: { + /** +

Left wheel angle, negative to the left, positive to the right.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GEAR LEFT STEER ANGLE': { name: 'GEAR LEFT STEER ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Left steer angle as a percentage. */ - GEAR_LEFT_STEER_ANGLE_PCT: { + 'GEAR LEFT STEER ANGLE PCT': { name: 'GEAR LEFT STEER ANGLE PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Position of landing gear. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'GEAR_POSITION:index': { + /** +

Position of landing gear.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GEAR POSITION:index': { name: 'GEAR POSITION:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Percent right gear extended. */ - GEAR_RIGHT_POSITION: { + 'GEAR RIGHT POSITION': { name: 'GEAR RIGHT POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Right wheel angle, negative to the left, positive to the right. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - GEAR_RIGHT_STEER_ANGLE: { + /** +

Right wheel angle, negative to the left, positive to the right.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GEAR RIGHT STEER ANGLE': { name: 'GEAR RIGHT STEER ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Right steer angle as a percentage. */ - GEAR_RIGHT_STEER_ANGLE_PCT: { + 'GEAR RIGHT STEER ANGLE PCT': { name: 'GEAR RIGHT STEER ANGLE PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The gear skidding factor, expressed as a value between 0 and 1. */ - GEAR_SKIDDING_FACTOR: { + 'GEAR SKIDDING FACTOR': { name: 'GEAR SKIDDING FACTOR', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if safe speed limit for gear exceeded. */ - GEAR_SPEED_EXCEEDED: { + 'GEAR SPEED EXCEEDED': { name: 'GEAR SPEED EXCEEDED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Alternative method of getting the steer angle. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'GEAR_STEER_ANGLE:index': { + /** +

Alternative method of getting the steer angle.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GEAR STEER ANGLE:index': { name: 'GEAR STEER ANGLE:index', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Alternative method of getting steer angle as a percentage. */ - 'GEAR_STEER_ANGLE_PCT:index': { + 'GEAR STEER ANGLE PCT:index': { name: 'GEAR STEER ANGLE PCT:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent tail gear extended. - NOTE: This is a deprecated legacy SimVar and should not be used, as it will always return 0. */ - GEAR_TAIL_POSITION: { + /** +

Percent tail gear extended.

+

NOTE: This is a deprecated legacy SimVar and should not be used, as it will always return 0.

+ */ + 'GEAR TAIL POSITION': { name: 'GEAR TAIL POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent total gear extended. */ - GEAR_TOTAL_PCT_EXTENDED: { + 'GEAR TOTAL PCT EXTENDED': { name: 'GEAR TOTAL PCT EXTENDED', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Gear warnings. */ - 'GEAR_WARNING:index': { + /** +

Gear warnings.

+ */ + 'GEAR WARNING:index': { name: 'GEAR WARNING:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** The depth of the gear in the water. */ - GEAR_WATER_DEPTH: { + 'GEAR WATER DEPTH': { name: 'GEAR WATER DEPTH', units: 'Centimeters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if landing gear are floats */ - IS_GEAR_FLOATS: { + 'IS GEAR FLOATS': { name: 'IS GEAR FLOATS', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if gear can be retracted */ - IS_GEAR_RETRACTABLE: { + 'IS GEAR RETRACTABLE': { name: 'IS GEAR RETRACTABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if landing gear is skids */ - IS_GEAR_SKIDS: { + 'IS GEAR SKIDS': { name: 'IS GEAR SKIDS', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if landing gear is skis */ - IS_GEAR_SKIS: { + 'IS GEAR SKIS': { name: 'IS GEAR SKIS', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if landing gear is wheels */ - IS_GEAR_WHEELS: { + 'IS GEAR WHEELS': { name: 'IS GEAR WHEELS', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Left wheel rotation angle (rotation around the axis for the wheel). */ - LEFT_WHEEL_ROTATION_ANGLE: { + 'LEFT WHEEL ROTATION ANGLE': { name: 'LEFT WHEEL ROTATION ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Left landing gear rpm */ - LEFT_WHEEL_RPM: { + 'LEFT WHEEL RPM': { name: 'LEFT WHEEL RPM', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** True if the nosewheel lock is engaged. This can be set using the NosewheelLock parameter. */ - NOSEWHEEL_LOCK_ON: { + /** True if the nosewheel lock is engaged. This can be set using the NosewheelLock parameter. */ + 'NOSEWHEEL LOCK ON': { name: 'NOSEWHEEL LOCK ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Can be used to get or set the maximum permitted steering angle for the nose wheel of the aircraft. */ - NOSEWHEEL_MAX_STEERING_ANGLE: { + 'NOSEWHEEL MAX STEERING ANGLE': { name: 'NOSEWHEEL MAX STEERING ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** True if retract float switch on */ - RETRACT_FLOAT_SWITCH: { + 'RETRACT FLOAT SWITCH': { name: 'RETRACT FLOAT SWITCH', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** If aircraft has retractable floats. */ - RETRACT_LEFT_FLOAT_EXTENDED: { + 'RETRACT LEFT FLOAT EXTENDED': { name: 'RETRACT LEFT FLOAT EXTENDED', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** If aircraft has retractable floats. */ - RETRACT_RIGHT_FLOAT_EXTENDED: { + 'RETRACT RIGHT FLOAT EXTENDED': { name: 'RETRACT RIGHT FLOAT EXTENDED', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Right wheel rotation angle (rotation around the axis for the wheel). */ - RIGHT_WHEEL_ROTATION_ANGLE: { + 'RIGHT WHEEL ROTATION ANGLE': { name: 'RIGHT WHEEL ROTATION ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Right landing gear rpm. */ - RIGHT_WHEEL_RPM: { + 'RIGHT WHEEL RPM': { name: 'RIGHT WHEEL RPM', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Position of steering tiller. */ - STEER_INPUT_CONTROL: { + 'STEER INPUT CONTROL': { name: 'STEER INPUT CONTROL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** True if tailwheel lock applied. This can be set using the TailwheelLock parameter. */ - TAILWHEEL_LOCK_ON: { + /** True if tailwheel lock applied. This can be set using the TailwheelLock parameter. */ + 'TAILWHEEL LOCK ON': { name: 'TAILWHEEL LOCK ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Percent extended. */ - WATER_LEFT_RUDDER_EXTENDED: { + 'WATER LEFT RUDDER EXTENDED': { name: 'WATER LEFT RUDDER EXTENDED', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Water left rudder angle, negative to the left, positive to the right. */ - WATER_LEFT_RUDDER_STEER_ANGLE: { + 'WATER LEFT RUDDER STEER ANGLE': { name: 'WATER LEFT RUDDER STEER ANGLE', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Water left rudder angle as a percentage. */ - WATER_LEFT_RUDDER_STEER_ANGLE_PCT: { + 'WATER LEFT RUDDER STEER ANGLE PCT': { name: 'WATER LEFT RUDDER STEER ANGLE PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent extended. */ - WATER_RIGHT_RUDDER_EXTENDED: { + 'WATER RIGHT RUDDER EXTENDED': { name: 'WATER RIGHT RUDDER EXTENDED', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Water right rudder angle, negative to the left, positive to the right. */ - WATER_RIGHT_RUDDER_STEER_ANGLE: { + 'WATER RIGHT RUDDER STEER ANGLE': { name: 'WATER RIGHT RUDDER STEER ANGLE', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Water right rudder as a percentage. */ - WATER_RIGHT_RUDDER_STEER_ANGLE_PCT: { + 'WATER RIGHT RUDDER STEER ANGLE PCT': { name: 'WATER RIGHT RUDDER STEER ANGLE PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Position of the water rudder handle (0 handle retracted, 1 rudder handle applied). */ - WATER_RUDDER_HANDLE_POSITION: { + 'WATER RUDDER HANDLE POSITION': { name: 'WATER RUDDER HANDLE POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Wheel rotation angle (rotation around the axis for the wheel). */ - 'WHEEL_ROTATION_ANGLE:index': { + 'WHEEL ROTATION ANGLE:index': { name: 'WHEEL ROTATION ANGLE:index', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Wheel rpm. */ - 'WHEEL_RPM:index': { + 'WHEEL RPM:index': { name: 'WHEEL RPM:index', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Angle deflection for the aileron. */ - AILERON_AVERAGE_DEFLECTION: { + 'AILERON AVERAGE DEFLECTION': { name: 'AILERON AVERAGE DEFLECTION', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Angle deflection for the aileron. */ - AILERON_LEFT_DEFLECTION: { + 'AILERON LEFT DEFLECTION': { name: 'AILERON LEFT DEFLECTION', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent deflection for the aileron. - NOTE: This is available in multiplayer to all near aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - AILERON_LEFT_DEFLECTION_PCT: { + /** +

Percent deflection for the aileron.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'AILERON LEFT DEFLECTION PCT': { name: 'AILERON LEFT DEFLECTION PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent aileron input left/right. */ - AILERON_POSITION: { + 'AILERON POSITION': { name: 'AILERON POSITION', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Angle deflection. */ - AILERON_RIGHT_DEFLECTION: { + 'AILERON RIGHT DEFLECTION': { name: 'AILERON RIGHT DEFLECTION', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent deflection. - NOTE: This is available in multiplayer to all near aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - AILERON_RIGHT_DEFLECTION_PCT: { + /** +

Percent deflection.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'AILERON RIGHT DEFLECTION PCT': { name: 'AILERON RIGHT DEFLECTION PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Angle deflection. */ - AILERON_TRIM: { + 'AILERON TRIM': { name: 'AILERON TRIM', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Whether or not the Aileron Trim has been disabled. */ - AILERON_TRIM_DISABLED: { + 'AILERON TRIM DISABLED': { name: 'AILERON TRIM DISABLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The trim position of the ailerons. Zero is fully retracted. - NOTE: This is available in multiplayer to all near aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - AILERON_TRIM_PCT: { + /** +

The trim position of the ailerons. Zero is fully retracted.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'AILERON TRIM PCT': { name: 'AILERON TRIM PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Angle deflection. */ - ELEVATOR_DEFLECTION: { + 'ELEVATOR DEFLECTION': { name: 'ELEVATOR DEFLECTION', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent deflection. - NOTE: This is available in multiplayer. See here for more information: -Note On SimVars In Multiplayer. */ - ELEVATOR_DEFLECTION_PCT: { + /** +

Percent deflection.

+

NOTE: This is available in multiplayer. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ELEVATOR DEFLECTION PCT': { name: 'ELEVATOR DEFLECTION PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent elevator input deflection. */ - ELEVATOR_POSITION: { + 'ELEVATOR POSITION': { name: 'ELEVATOR POSITION', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Whether or not the Elevator Trim has been disabled. */ - ELEVATOR_TRIM_DISABLED: { + 'ELEVATOR TRIM DISABLED': { name: 'ELEVATOR TRIM DISABLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Returns the maximum elevator trim value. This corresponds to the elevator_trim_down_limit in the Flight Model Config file. */ - ELEVATOR_TRIM_DOWN_LIMIT: { + /** Returns the maximum elevator trim value. This corresponds to the elevator_trim_down_limit in the Flight Model Config file. */ + 'ELEVATOR TRIM DOWN LIMIT': { name: 'ELEVATOR TRIM DOWN LIMIT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent elevator trim (for indication). */ - ELEVATOR_TRIM_INDICATOR: { + 'ELEVATOR TRIM INDICATOR': { name: 'ELEVATOR TRIM INDICATOR', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Elevator trim neutral. */ - ELEVATOR_TRIM_NEUTRAL: { + 'ELEVATOR TRIM NEUTRAL': { name: 'ELEVATOR TRIM NEUTRAL', - units: 'Radians', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent elevator trim. */ - ELEVATOR_TRIM_PCT: { + 'ELEVATOR TRIM PCT': { name: 'ELEVATOR TRIM PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Elevator trim deflection. */ - ELEVATOR_TRIM_POSITION: { + 'ELEVATOR TRIM POSITION': { name: 'ELEVATOR TRIM POSITION', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Returns the maximum elevator trim value. This corresponds to the elevator_trim_up_limit in the Flight Model Config file. */ - ELEVATOR_TRIM_UP_LIMIT: { + /** Returns the maximum elevator trim value. This corresponds to the elevator_trim_up_limit in the Flight Model Config file. */ + 'ELEVATOR TRIM UP LIMIT': { name: 'ELEVATOR TRIM UP LIMIT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Elevon deflection. */ - ELEVON_DEFLECTION: { + 'ELEVON DEFLECTION': { name: 'ELEVON DEFLECTION', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if flaps are damaged by excessive speed. */ - FLAP_DAMAGE_BY_SPEED: { + 'FLAP DAMAGE BY SPEED': { name: 'FLAP DAMAGE BY SPEED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Set the position of the flaps control. */ - FLAP_POSITION_SET: { + 'FLAP POSITION SET': { name: 'FLAP POSITION SET', units: 'Position', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** True if safe speed limit for flaps exceeded. */ - FLAP_SPEED_EXCEEDED: { + 'FLAP SPEED EXCEEDED': { name: 'FLAP SPEED EXCEEDED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if flaps available. */ - FLAPS_AVAILABLE: { + 'FLAPS AVAILABLE': { name: 'FLAPS AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This returns the effective flaps handle index, after some of the conditions have potentially forced the state to change. */ - 'FLAPS_EFFECTIVE_HANDLE_INDEX:index': { + /** This returns the effective flaps handle index, after some of the conditions have potentially forced the state to change. */ + 'FLAPS EFFECTIVE HANDLE INDEX:index': { name: 'FLAPS EFFECTIVE HANDLE INDEX:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Index of current flap position. */ - 'FLAPS_HANDLE_INDEX:index': { + 'FLAPS HANDLE INDEX:index': { name: 'FLAPS HANDLE INDEX:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Percent flap handle extended. - NOTE: This is available in multiplayer -to all near aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - FLAPS_HANDLE_PERCENT: { + /** +

Percent flap handle extended.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'FLAPS HANDLE PERCENT': { name: 'FLAPS HANDLE PERCENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Number of available flap positions. */ - FLAPS_NUM_HANDLE_POSITIONS: { + 'FLAPS NUM HANDLE POSITIONS': { name: 'FLAPS NUM HANDLE POSITIONS', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Angle left leading edge flap extended. Use LEADING_EDGE_FLAPS_LEFT_PERCENT to set a value. */ - LEADING_EDGE_FLAPS_LEFT_ANGLE: { + /** Angle left leading edge flap extended. Use LEADING_EDGE_FLAPS_LEFT_PERCENT to set a value. */ + 'LEADING EDGE FLAPS LEFT ANGLE': { name: 'LEADING EDGE FLAPS LEFT ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Index of left leading edge flap position. */ - LEADING_EDGE_FLAPS_LEFT_INDEX: { + 'LEADING EDGE FLAPS LEFT INDEX': { name: 'LEADING EDGE FLAPS LEFT INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent left leading edge flap extended. - NOTE: This is available in multiplayer -to all near aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LEADING_EDGE_FLAPS_LEFT_PERCENT: { + /** +

Percent left leading edge flap extended.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LEADING EDGE FLAPS LEFT PERCENT': { name: 'LEADING EDGE FLAPS LEFT PERCENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Angle right leading edge flap extended. Use LEADING_EDGE_FLAPS_RIGHT_PERCENT to set a value. */ - LEADING_EDGE_FLAPS_RIGHT_ANGLE: { + /** Angle right leading edge flap extended. Use LEADING_EDGE_FLAPS_RIGHT_PERCENT to set a value. */ + 'LEADING EDGE FLAPS RIGHT ANGLE': { name: 'LEADING EDGE FLAPS RIGHT ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Index of right leading edge flap position. */ - LEADING_EDGE_FLAPS_RIGHT_INDEX: { + 'LEADING EDGE FLAPS RIGHT INDEX': { name: 'LEADING EDGE FLAPS RIGHT INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent right leading edge flap extended. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LEADING_EDGE_FLAPS_RIGHT_PERCENT: { + /** +

Percent right leading edge flap extended.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LEADING EDGE FLAPS RIGHT PERCENT': { name: 'LEADING EDGE FLAPS RIGHT PERCENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Angle left trailing edge flap extended. Use TRAILING_EDGE_FLAPS_LEFT_PERCENT to set a value. */ - TRAILING_EDGE_FLAPS_LEFT_ANGLE: { + /** Angle left trailing edge flap extended. Use TRAILING_EDGE_FLAPS_LEFT_PERCENT to set a value. */ + 'TRAILING EDGE FLAPS LEFT ANGLE': { name: 'TRAILING EDGE FLAPS LEFT ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Index of left trailing edge flap position. */ - TRAILING_EDGE_FLAPS_LEFT_INDEX: { + 'TRAILING EDGE FLAPS LEFT INDEX': { name: 'TRAILING EDGE FLAPS LEFT INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent left trailing edge flap extended. - NOTE: This is available in multiplayer -to all near aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - TRAILING_EDGE_FLAPS_LEFT_PERCENT: { + /** +

Percent left trailing edge flap extended.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'TRAILING EDGE FLAPS LEFT PERCENT': { name: 'TRAILING EDGE FLAPS LEFT PERCENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Angle right trailing edge flap extended. Use TRAILING_EDGE_FLAPS_RIGHT_PERCENT to set a value. */ - TRAILING_EDGE_FLAPS_RIGHT_ANGLE: { + /** Angle right trailing edge flap extended. Use TRAILING_EDGE_FLAPS_RIGHT_PERCENT to set a value. */ + 'TRAILING EDGE FLAPS RIGHT ANGLE': { name: 'TRAILING EDGE FLAPS RIGHT ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Index of right trailing edge flap position. */ - TRAILING_EDGE_FLAPS_RIGHT_INDEX: { + 'TRAILING EDGE FLAPS RIGHT INDEX': { name: 'TRAILING EDGE FLAPS RIGHT INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent right trailing edge flap extended. - NOTE: This is available in multiplayer -to all near aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - TRAILING_EDGE_FLAPS_RIGHT_PERCENT: { + /** +

Percent right trailing edge flap extended.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'TRAILING EDGE FLAPS RIGHT PERCENT': { name: 'TRAILING EDGE FLAPS RIGHT PERCENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Returns true if the fly-by-wire alpha protection is enabled or false otherwise. */ - FLY_BY_WIRE_ALPHA_PROTECTION: { + 'FLY BY WIRE ALPHA PROTECTION': { name: 'FLY BY WIRE ALPHA PROTECTION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the Elevators and Ailerons computer has failed. */ - FLY_BY_WIRE_ELAC_FAILED: { + 'FLY BY WIRE ELAC FAILED': { name: 'FLY BY WIRE ELAC FAILED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the fly by wire Elevators and Ailerons computer is on. */ - FLY_BY_WIRE_ELAC_SWITCH: { + 'FLY BY WIRE ELAC SWITCH': { name: 'FLY BY WIRE ELAC SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the Flight Augmentation computer has failed. */ - FLY_BY_WIRE_FAC_FAILED: { + 'FLY BY WIRE FAC FAILED': { name: 'FLY BY WIRE FAC FAILED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the fly by wire Flight Augmentation computer is on. */ - FLY_BY_WIRE_FAC_SWITCH: { + 'FLY BY WIRE FAC SWITCH': { name: 'FLY BY WIRE FAC SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the Spoilers and Elevators computer has failed. */ - FLY_BY_WIRE_SEC_FAILED: { + 'FLY BY WIRE SEC FAILED': { name: 'FLY BY WIRE SEC FAILED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the fly by wire Spoilers and Elevators computer is on. */ - FLY_BY_WIRE_SEC_SWITCH: { + 'FLY BY WIRE SEC SWITCH': { name: 'FLY BY WIRE SEC SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the folding wing handle is engaged. */ - FOLDING_WING_HANDLE_POSITION: { + 'FOLDING WING HANDLE POSITION': { name: 'FOLDING WING HANDLE POSITION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Left folding wing position, 1.0 is fully folded. */ - FOLDING_WING_LEFT_PERCENT: { + 'FOLDING WING LEFT PERCENT': { name: 'FOLDING WING LEFT PERCENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Right folding wing position, 1.0 is fully folded. */ - FOLDING_WING_RIGHT_PERCENT: { + 'FOLDING WING RIGHT PERCENT': { name: 'FOLDING WING RIGHT PERCENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Angle deflection. */ - RUDDER_DEFLECTION: { + 'RUDDER DEFLECTION': { name: 'RUDDER DEFLECTION', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent deflection. - NOTE: This is available in multiplayer. See here for more information: -Note On SimVars In Multiplayer. */ - RUDDER_DEFLECTION_PCT: { + /** +

Percent deflection.

+

NOTE: This is available in multiplayer. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'RUDDER DEFLECTION PCT': { name: 'RUDDER DEFLECTION PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Rudder pedal position. */ - RUDDER_PEDAL_INDICATOR: { + 'RUDDER PEDAL INDICATOR': { name: 'RUDDER PEDAL INDICATOR', units: 'Position', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent rudder pedal deflection (for animation). */ - RUDDER_PEDAL_POSITION: { + 'RUDDER PEDAL POSITION': { name: 'RUDDER PEDAL POSITION', - units: 'Position (-16K to 0)', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Percent rudder input deflection. */ - RUDDER_POSITION: { + 'RUDDER POSITION': { name: 'RUDDER POSITION', - units: 'Position (-16K to 0)', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Angle deflection. */ - RUDDER_TRIM: { + 'RUDDER TRIM': { name: 'RUDDER TRIM', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Whether or not the Rudder Trim has been disabled. */ - RUDDER_TRIM_DISABLED: { + 'RUDDER TRIM DISABLED': { name: 'RUDDER TRIM DISABLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The trim position of the rudder. Zero is no trim. */ - RUDDER_TRIM_PCT: { + 'RUDDER TRIM PCT': { name: 'RUDDER TRIM PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Checks if autospoilers are armed (true) or not (false). */ - SPOILERS_ARMED: { + 'SPOILERS ARMED': { name: 'SPOILERS ARMED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if spoiler system available. */ - SPOILER_AVAILABLE: { + 'SPOILER AVAILABLE': { name: 'SPOILER AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Spoiler handle position. */ - SPOILERS_HANDLE_POSITION: { + 'SPOILERS HANDLE POSITION': { name: 'SPOILERS HANDLE POSITION', - units: 'Percent Over 100', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Percent left spoiler deflected. - NOTE: This is available in multiplayer. See here for more information: -Note On SimVars In Multiplayer. */ - SPOILERS_LEFT_POSITION: { + /** +

Percent left spoiler deflected.

+

NOTE: This is available in multiplayer. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'SPOILERS LEFT POSITION': { name: 'SPOILERS LEFT POSITION', - units: 'Percent Over 100', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent right spoiler deflected. - NOTE: This is available in multiplayer. See here for more information: -Note On SimVars In Multiplayer. */ - SPOILERS_RIGHT_POSITION: { + /** +

Percent right spoiler deflected.

+

NOTE: This is available in multiplayer. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'SPOILERS RIGHT POSITION': { name: 'SPOILERS RIGHT POSITION', - units: 'Percent Over 100', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Indexed from 1, 100 is fully deployed, 0 flat on deck */ - 'BLAST_SHIELD_POSITION:index': { + 'BLAST SHIELD POSITION:index': { name: 'BLAST SHIELD POSITION:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** A number 1 through 4 for the cable number caught by the tailhook. Cable 1 is the one closest to the stern of the carrier. A value of 0 indicates no cable was caught. */ - 'CABLE_CAUGHT_BY_TAILHOOK:index': { + 'CABLE CAUGHT BY TAILHOOK:index': { name: 'CABLE CAUGHT BY TAILHOOK:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Catapults are indexed from 1. This value will be 0 before the catapult fires, and then up to 100 as the aircraft is propelled down the catapult. The aircraft may takeoff before the value reaches 100 (depending on the aircraft weight, power applied, and other factors), in which case this value will not be further updated. This value could be used to drive a bogie animation. */ - 'CATAPULT_STROKE_POSITION:index': { + 'CATAPULT STROKE POSITION:index': { name: 'CATAPULT STROKE POSITION:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Holdback bars allow build up of thrust before takeoff from a catapult, and are installed by the deck crew of an aircraft carrier. */ - HOLDBACK_BAR_INSTALLED: { + 'HOLDBACK BAR INSTALLED': { name: 'HOLDBACK BAR INSTALLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** This will be True if the launchbar is fully extended, and can be used, for example, to change the color of an instrument light. */ - LAUNCHBAR_HELD_EXTENDED: { + 'LAUNCHBAR HELD EXTENDED': { name: 'LAUNCHBAR HELD EXTENDED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Installed on aircraft before takeoff from a carrier catapult. Note that gear cannot retract with this extended. 100 = fully extended. */ - LAUNCHBAR_POSITION: { + 'LAUNCHBAR POSITION': { name: 'LAUNCHBAR POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** If this is set to True the launch bar switch has been engaged. */ - LAUNCHBAR_SWITCH: { + 'LAUNCHBAR SWITCH': { name: 'LAUNCHBAR SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Maximum of 4. A model can contain more than 4 catapults, but only the first four will be read and recognized by the simulation. */ - NUMBER_OF_CATAPULTS: { + 'NUMBER OF CATAPULTS': { name: 'NUMBER OF CATAPULTS', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The nose angle, where 0 is fully up. */ - CONCORDE_NOSE_ANGLE: { + 'CONCORDE NOSE ANGLE': { name: 'CONCORDE NOSE ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The visor nose handle position. */ - CONCORDE_VISOR_NOSE_HANDLE: { + 'CONCORDE VISOR NOSE HANDLE': { name: 'CONCORDE VISOR NOSE HANDLE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** The visor position expressed as a percentage where 0.0 = up and 1.0 = extended/down. */ - CONCORDE_VISOR_POSITION_PERCENT: { + /** +

The visor position expressed as a percentage where 0.0 = up and 1.0 = extended/down.

+ */ + 'CONCORDE VISOR POSITION PERCENT': { name: 'CONCORDE VISOR POSITION PERCENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This is a settable simvar meaning that it can both be read and set. Some of the simvars in this list are using this to lookup a value using two arguments (one argument in addition to the component index). For example to check the state of the connection between a "circuit.45" and the "bus.2" it would be written as follows: - 2 (>A:BUS LOOKUP INDEX, Number) (A:CIRCUIT CONNECTION ON:45, Bool) - It should be notes that when BUS_LOOKUP_INDEX is not set (ie: it is 0) then TRUE will be returned if any of your bus connections are on. */ - BUS_LOOKUP_INDEX: { + /** +

This is a settable simvar meaning that it can both be read and set. Some of the simvars in this list are using this to lookup a value using two arguments (one argument in addition to the component index). For example to check the state of the connection between a "circuit.45" and the "bus.2" it would be written as follows:

+

2 (>A:BUS LOOKUP INDEX, Number) (A:CIRCUIT CONNECTION ON:45, Bool)

+

It should be notes that when BUS_LOOKUP_INDEX is not set (ie: it is 0) then TRUE will be returned if any of your bus connections are on.

+ */ + 'BUS LOOKUP INDEX': { name: 'BUS LOOKUP INDEX', units: '-', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This will be true if the bus breaker is pulled. Requires a BUS_LOOKUP_INDEX and a bus index. */ - BUS_BREAKER_PULLED: { + /** This will be true if the bus breaker is pulled. Requires a BUS_LOOKUP_INDEX and a bus index. */ + 'BUS BREAKER PULLED': { name: 'BUS BREAKER PULLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** This will be true if the bus is connected. Requires a BUS_LOOKUP_INDEX and a bus index. */ - BUS_CONNECTION_ON: { + /** This will be true if the bus is connected. Requires a BUS_LOOKUP_INDEX and a bus index. */ + 'BUS CONNECTION ON': { name: 'BUS CONNECTION ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This returns the percentage of the load output that is being consumed. This requires an alternator index when referencing. */ - ELECTRICAL_GENALT_LOAD: { + /** +

This returns the percentage of the load output that is being consumed. This requires an alternator index when referencing.

+ */ + 'ELECTRICAL GENALT LOAD': { name: 'ELECTRICAL GENALT LOAD', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The load handled by the alternator. This requires an alternator index when referencing. */ - ELECTRICAL_GENALT_BUS_AMPS: { + 'ELECTRICAL GENALT BUS AMPS': { name: 'ELECTRICAL GENALT BUS AMPS', units: 'Amperes', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** General alternator voltage. This requires an alternator index when referencing. */ - ELECTRICAL_GENALT_BUS_VOLTAGE: { + 'ELECTRICAL GENALT BUS VOLTAGE': { name: 'ELECTRICAL GENALT BUS VOLTAGE', units: 'Volts', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The main bus voltage. Use a bus index when referencing. */ - ELECTRICAL_MAIN_BUS_VOLTAGE: { + 'ELECTRICAL MAIN BUS VOLTAGE': { name: 'ELECTRICAL MAIN BUS VOLTAGE', units: 'Volts', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Avionics bus current */ - ELECTRICAL_AVIONICS_BUS_AMPS: { + 'ELECTRICAL AVIONICS BUS AMPS': { name: 'ELECTRICAL AVIONICS BUS AMPS', units: 'Amperes', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Avionics bus voltage */ - ELECTRICAL_AVIONICS_BUS_VOLTAGE: { + 'ELECTRICAL AVIONICS BUS VOLTAGE': { name: 'ELECTRICAL AVIONICS BUS VOLTAGE', units: 'Volts', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Main bus current */ - ELECTRICAL_MAIN_BUS_AMPS: { + 'ELECTRICAL MAIN BUS AMPS': { name: 'ELECTRICAL MAIN BUS AMPS', units: 'Amperes', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Deprecated, do not use! - Use ELECTRICAL BATTERY LOAD. */ - ELECTRICAL_OLD_CHARGING_AMPS: { + /** +

Deprecated, do not use!

+

Use ELECTRICAL BATTERY LOAD.

+ */ + 'ELECTRICAL OLD CHARGING AMPS': { name: 'ELECTRICAL OLD CHARGING AMPS', units: 'Amps', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Total load amps */ - ELECTRICAL_TOTAL_LOAD_AMPS: { + 'ELECTRICAL TOTAL LOAD AMPS': { name: 'ELECTRICAL TOTAL LOAD AMPS', units: 'Amperes', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Is the aircraft using the new Electrical System or the legacy FSX one. */ - NEW_ELECTRICAL_SYSTEM: { + /** Is the aircraft using the new Electrical System or the legacy FSX one. */ + 'NEW ELECTRICAL SYSTEM': { name: 'NEW ELECTRICAL SYSTEM', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This will be true if the alternator breaker is pulled. Requires a BUS_LOOKUP_INDEX and an alternator index. */ - ALTERNATOR_BREAKER_PULLED: { + /** This will be true if the alternator breaker is pulled. Requires a BUS_LOOKUP_INDEX and an alternator index. */ + 'ALTERNATOR BREAKER PULLED': { name: 'ALTERNATOR BREAKER PULLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** This will be true if the alternator is connected. Requires a BUS_LOOKUP_INDEX and an alternator index. */ - ALTERNATOR_CONNECTION_ON: { + /** This will be true if the alternator is connected. Requires a BUS_LOOKUP_INDEX and an alternator index. */ + 'ALTERNATOR CONNECTION ON': { name: 'ALTERNATOR CONNECTION ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The alternator (generator) switch position, true if the switch is ON. Requires an engine index, and the use of an alternator index when referencing. */ - 'GENERAL_ENG_MASTER_ALTERNATOR:index': { + /** The alternator (generator) switch position, true if the switch is ON. Requires an engine index, and the use of an alternator index when referencing. */ + 'GENERAL ENG MASTER ALTERNATOR:index': { name: 'GENERAL ENG MASTER ALTERNATOR:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Bleed air pressure received by the engine from the APU. */ - APU_BLEED_PRESSURE_RECEIVED_BY_ENGINE: { + /** Bleed air pressure received by the engine from the APU. */ + 'APU BLEED PRESSURE RECEIVED BY ENGINE': { name: 'APU BLEED PRESSURE RECEIVED BY ENGINE', units: 'Pounds per square inch (psi)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Set or get whether an APU is active (true) or not (false). Takes an index to be able to have multiple generators on a single APU. */ - 'APU_GENERATOR_ACTIVE:index': { + /** Set or get whether an APU is active (true) or not (false). Takes an index to be able to have multiple generators on a single APU. */ + 'APU GENERATOR ACTIVE:index': { name: 'APU GENERATOR ACTIVE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Enables or disables the APU for an engine. Takes an index to be able to have multiple generators on a single APU */ - 'APU_GENERATOR_SWITCH:index': { + /** +

Enables or disables the APU for an engine. Takes an index to be able to have multiple generators on a single APU

+ */ + 'APU GENERATOR SWITCH:index': { name: 'APU GENERATOR SWITCH:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Will return true if the APU is on fire, or false otherwise. */ - APU_ON_FIRE_DETECTED: { + /** Will return true if the APU is on fire, or false otherwise. */ + 'APU ON FIRE DETECTED': { name: 'APU ON FIRE DETECTED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Auxiliary power unit RPM, as a percentage */ - APU_PCT_RPM: { + /** Auxiliary power unit RPM, as a percentage */ + 'APU PCT RPM': { name: 'APU PCT RPM', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Auxiliary power unit starter, as a percentage */ - APU_PCT_STARTER: { + 'APU PCT STARTER': { name: 'APU PCT STARTER', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Boolean, whether or not the APU is switched on. */ - APU_SWITCH: { + /** Boolean, whether or not the APU is switched on. */ + 'APU SWITCH': { name: 'APU SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** The volts from the APU to the selected engine. Takes an index to be able to have multiple generators on a single APU. */ - 'APU_VOLTS:index': { + /** +

The volts from the APU to the selected engine. Takes an index to be able to have multiple generators on a single APU.

+ */ + 'APU VOLTS:index': { name: 'APU VOLTS:index', units: 'Volts', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Boolean, returns whether or not the APU attempts to provide Bleed Air. */ - BLEED_AIR_APU: { + /** Boolean, returns whether or not the APU attempts to provide Bleed Air. */ + 'BLEED AIR APU': { name: 'BLEED AIR APU', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This will be true if the battery breaker is pulled. Requires a BUS LOOKUP INDEX and a battery index. */ - BATTERY_BREAKER_PULLED: { + /** This will be true if the battery breaker is pulled. Requires a BUS LOOKUP INDEX and a battery index. */ + 'BATTERY BREAKER PULLED': { name: 'BATTERY BREAKER PULLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** This will be true if the battery is connected. Requires a BUS_LOOKUP_INDEX and a battery index. */ - BATTERY_CONNECTION_ON: { + /** This will be true if the battery is connected. Requires a BUS_LOOKUP_INDEX and a battery index. */ + 'BATTERY CONNECTION ON': { name: 'BATTERY CONNECTION ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Battery bus current */ - ELECTRICAL_BATTERY_BUS_AMPS: { + 'ELECTRICAL BATTERY BUS AMPS': { name: 'ELECTRICAL BATTERY BUS AMPS', units: 'Amperes', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Battery bus voltage */ - ELECTRICAL_BATTERY_BUS_VOLTAGE: { + 'ELECTRICAL BATTERY BUS VOLTAGE': { name: 'ELECTRICAL BATTERY BUS VOLTAGE', units: 'Volts', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Battery capacity over max capacity, 100 is full. */ - ELECTRICAL_BATTERY_ESTIMATED_CAPACITY_PCT: { + 'ELECTRICAL BATTERY ESTIMATED CAPACITY PCT': { name: 'ELECTRICAL BATTERY ESTIMATED CAPACITY PCT', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The load handled by the battery (negative values mean the battery is receiving current). Use a battery index when referencing. */ - ELECTRICAL_BATTERY_LOAD: { + /** The load handled by the battery (negative values mean the battery is receiving current). Use a battery index when referencing. */ + 'ELECTRICAL BATTERY LOAD': { name: 'ELECTRICAL BATTERY LOAD', units: 'Amperes', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The battery voltage. Use a battery index when referencing. */ - ELECTRICAL_BATTERY_VOLTAGE: { + /** +

The battery voltage. Use a battery index when referencing.

+ */ + 'ELECTRICAL BATTERY VOLTAGE': { name: 'ELECTRICAL BATTERY VOLTAGE', units: 'Volts', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current available when battery switch is turned off */ - ELECTRICAL_HOT_BATTERY_BUS_AMPS: { + 'ELECTRICAL HOT BATTERY BUS AMPS': { name: 'ELECTRICAL HOT BATTERY BUS AMPS', units: 'Amperes', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Voltage available when battery switch is turned off */ - ELECTRICAL_HOT_BATTERY_BUS_VOLTAGE: { + 'ELECTRICAL HOT BATTERY BUS VOLTAGE': { name: 'ELECTRICAL HOT BATTERY BUS VOLTAGE', units: 'Volts', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The battery switch position, true if the switch is ON. Use a battery index when referencing. */ - ELECTRICAL_MASTER_BATTERY: { + /** The battery switch position, true if the switch is ON. Use a battery index when referencing. */ + 'ELECTRICAL MASTER BATTERY': { name: 'ELECTRICAL MASTER BATTERY', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** All these SimVars can be used to get or set the breaker state for the electrical system (either true or false). - If the breaker is popped (set to false), then the associated circuit will not receive electricity. */ - BREAKER_ADF: { + /** +

All these SimVars can be used to get or set the breaker state for the electrical system (either true or false).

+

If the breaker is popped (set to false), then the associated circuit will not receive electricity.

+ */ + 'BREAKER ADF': { name: 'BREAKER ADF', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Bool */ - BREAKER_ALTFLD: { + 'BREAKER ALTFLD': { name: 'BREAKER ALTFLD', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_AUTOPILOT: { + 'BREAKER AUTOPILOT': { name: 'BREAKER AUTOPILOT', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_AVNBUS1: { + 'BREAKER AVNBUS1': { name: 'BREAKER AVNBUS1', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_AVNBUS2: { + 'BREAKER AVNBUS2': { name: 'BREAKER AVNBUS2', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_AVNFAN: { + 'BREAKER AVNFAN': { name: 'BREAKER AVNFAN', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_FLAP: { + 'BREAKER FLAP': { name: 'BREAKER FLAP', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_GPS: { + 'BREAKER GPS': { name: 'BREAKER GPS', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_INST: { + 'BREAKER INST': { name: 'BREAKER INST', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_INSTLTS: { + 'BREAKER INSTLTS': { name: 'BREAKER INSTLTS', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_LTS_PWR: { + 'BREAKER LTS PWR': { name: 'BREAKER LTS PWR', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Bool */ - BREAKER_NAVCOM1: { + 'BREAKER NAVCOM1': { name: 'BREAKER NAVCOM1', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_NAVCOM2: { + 'BREAKER NAVCOM2': { name: 'BREAKER NAVCOM2', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_NAVCOM3: { + 'BREAKER NAVCOM3': { name: 'BREAKER NAVCOM3', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_TURNCOORD: { + 'BREAKER TURNCOORD': { name: 'BREAKER TURNCOORD', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_WARN: { + 'BREAKER WARN': { name: 'BREAKER WARN', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Bool */ - BREAKER_XPNDR: { + 'BREAKER XPNDR': { name: 'BREAKER XPNDR', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Is electrical power available to this circuit */ - CIRCUIT_AUTOPILOT_ON: { + 'CIRCUIT AUTOPILOT ON': { name: 'CIRCUIT AUTOPILOT ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to this circuit */ - CIRCUIT_AUTO_BRAKES_ON: { + 'CIRCUIT AUTO BRAKES ON': { name: 'CIRCUIT AUTO BRAKES ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Is electrical power available to this circuit. Please see the -Note On Autofeathering for more information. */ - CIRCUIT_AUTO_FEATHER_ON: { + /** +

Is electrical power available to this circuit. Please see the Note On Autofeathering for more information.

+ */ + 'CIRCUIT AUTO FEATHER ON': { name: 'CIRCUIT AUTO FEATHER ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to this circuit */ - CIRCUIT_AVIONICS_ON: { + 'CIRCUIT AVIONICS ON': { name: 'CIRCUIT AVIONICS ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This will be true if the circuit breaker is pulled. Requires a BUS_LOOKUP_INDEX and a circuit index. */ - CIRCUIT_BREAKER_PULLED: { + /** This will be true if the circuit breaker is pulled. Requires a BUS_LOOKUP_INDEX and a circuit index. */ + 'CIRCUIT BREAKER PULLED': { name: 'CIRCUIT BREAKER PULLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** This will be true if the circuit is connected. Requires a BUS_LOOKUP_INDEX and a circuit index. */ - CIRCUIT_CONNECTION_ON: { + /** +

This will be true if the circuit is connected. Requires a BUS_LOOKUP_INDEX and a circuit index.

+ */ + 'CIRCUIT CONNECTION ON': { name: 'CIRCUIT CONNECTION ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to the flap motor circuit */ - CIRCUIT_FLAP_MOTOR_ON: { + 'CIRCUIT FLAP MOTOR ON': { name: 'CIRCUIT FLAP MOTOR ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to the gear motor circuit */ - CIRCUIT_GEAR_MOTOR_ON: { + 'CIRCUIT GEAR MOTOR ON': { name: 'CIRCUIT GEAR MOTOR ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to gear warning circuit */ - CIRCUIT_GEAR_WARNING_ON: { + 'CIRCUIT GEAR WARNING ON': { name: 'CIRCUIT GEAR WARNING ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to the general panel circuit */ - CIRCUIT_GENERAL_PANEL_ON: { + 'CIRCUIT GENERAL PANEL ON': { name: 'CIRCUIT GENERAL PANEL ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to the hydraulic pump circuit */ - CIRCUIT_HYDRAULIC_PUMP_ON: { + 'CIRCUIT HYDRAULIC PUMP ON': { name: 'CIRCUIT HYDRAULIC PUMP ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to the marker beacon circuit */ - CIRCUIT_MARKER_BEACON_ON: { + 'CIRCUIT MARKER BEACON ON': { name: 'CIRCUIT MARKER BEACON ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not power is available to the NAVCOM1 circuit. */ - CIRCUIT_NAVCOM1_ON: { + 'CIRCUIT NAVCOM1 ON': { name: 'CIRCUIT NAVCOM1 ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not power is available to the NAVCOM2 circuit. */ - CIRCUIT_NAVCOM2_ON: { + 'CIRCUIT NAVCOM2 ON': { name: 'CIRCUIT NAVCOM2 ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not power is available to the NAVCOM3 circuit. */ - CIRCUIT_NAVCOM3_ON: { + 'CIRCUIT NAVCOM3 ON': { name: 'CIRCUIT NAVCOM3 ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This will be true if the given circuit is functioning. Use a circuit index when referencing. */ - CIRCUIT_ON: { + /** This will be true if the given circuit is functioning. Use a circuit index when referencing. */ + 'CIRCUIT ON': { name: 'CIRCUIT ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to the pitot heat circuit */ - CIRCUIT_PITOT_HEAT_ON: { + 'CIRCUIT PITOT HEAT ON': { name: 'CIRCUIT PITOT HEAT ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** This returns the percentage of use that the circuit is getting. This requires a circuit index when referencing. */ - CIRCUIT_POWER_SETTING: { + 'CIRCUIT POWER SETTING': { name: 'CIRCUIT POWER SETTING', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Is electrical power available to the propeller sync circuit */ - CIRCUIT_PROP_SYNC_ON: { + 'CIRCUIT PROP SYNC ON': { name: 'CIRCUIT PROP SYNC ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is electrical power available to the vacuum circuit */ - CIRCUIT_STANDBY_VACUUM_ON: { + 'CIRCUIT STANDBY VACUUM ON': { name: 'CIRCUIT STANDBY VACUUM ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The circuit switch position, true if the switch is ON. Use a circuit index when referencing. */ - CIRCUIT_SWITCH_ON: { + /** The circuit switch position, true if the switch is ON. Use a circuit index when referencing. */ + 'CIRCUIT SWITCH ON': { name: 'CIRCUIT SWITCH ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This will be true if the given external power source is available. Use an external power index when referencing. */ - EXTERNAL_POWER_AVAILABLE: { + /** This will be true if the given external power source is available. Use an external power index when referencing. */ + 'EXTERNAL POWER AVAILABLE': { name: 'EXTERNAL POWER AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Boolean, The state of the breaker of an external power source */ - EXTERNAL_POWER_BREAKER_PULLED: { + 'EXTERNAL POWER BREAKER PULLED': { name: 'EXTERNAL POWER BREAKER PULLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Boolean, The state of the connection between a bus and an external power source */ - EXTERNAL_POWER_CONNECTION_ON: { + 'EXTERNAL POWER CONNECTION ON': { name: 'EXTERNAL POWER CONNECTION ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The external power switch position, true if the switch is ON. Use an external power index when referencing. */ - EXTERNAL_POWER_ON: { + /** The external power switch position, true if the switch is ON. Use an external power index when referencing. */ + 'EXTERNAL POWER ON': { name: 'EXTERNAL POWER ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Returns whether or not the indexed engine (see note) attempts to provide bleed air. */ - 'BLEED_AIR_ENGINE:index': { + /** Returns whether or not the indexed engine (see note) attempts to provide bleed air. */ + 'BLEED AIR ENGINE:index': { name: 'BLEED AIR ENGINE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The bleed air system source controller for an indexed engine (see note). This will work as follows: - - When engines and APU are activated, it will return 0 because it is in Auto. - If the APU is removed, it will return 3 for engines only. - If instead the engines are removed, it would return 2 for the APU only. - If the APU and engines are removed, it would return 1 (so, off). */ - 'BLEED_AIR_SOURCE_CONTROL:index': { + /** +

The bleed air system source controller for an indexed engine (see note). This will work as follows:

+
    +
  • When engines and APU are activated, it will return 0 because it is in Auto.
    • +
  • If the APU is removed, it will return 3 for engines only.
    • +
  • If instead the engines are removed, it would return 2 for the APU only.
    • +
  • If the APU and engines are removed, it would return 1 (so, off).
    • +
+ */ + 'BLEED AIR SOURCE CONTROL:index': { name: 'BLEED AIR SOURCE CONTROL:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Deprecated, do not use! */ - COWL_FLAPS: { + /** Deprecated, do not use! */ + 'COWL FLAPS': { name: 'COWL FLAPS', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Selected engines (combination of bit flags) */ - ENGINE_CONTROL_SELECT: { + 'ENGINE CONTROL SELECT': { name: 'ENGINE CONTROL SELECT', - units: 'Flags:', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** True if engine mixture is available for prop engines. Deprecated, do not use (mixture is always available)! */ - ENGINE_MIXURE_AVAILABLE: { + /** +

True if engine mixture is available for prop engines. Deprecated, do not use (mixture is always available)!

+ */ + 'ENGINE MIXURE AVAILABLE': { name: 'ENGINE MIXURE AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The engine primer position. */ - ENGINE_PRIMER: { + 'ENGINE PRIMER': { name: 'ENGINE PRIMER', units: 'Position', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Engine type. */ - ENGINE_TYPE: { + 'ENGINE TYPE': { name: 'ENGINE TYPE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Anti-ice switch for the indexed engine (see note), true if enabled false otherwise. */ - 'ENG_ANTI_ICE:index': { + /** Anti-ice switch for the indexed engine (see note), true if enabled false otherwise. */ + 'ENG ANTI ICE:index': { name: 'ENG ANTI ICE:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** True if the indexed engine (see note) is running, false otherwise. */ - 'ENG_COMBUSTION:index': { + /** True if the indexed engine (see note) is running, false otherwise. */ + 'ENG COMBUSTION:index': { name: 'ENG COMBUSTION:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The indexed engine (see note) cylinder head temperature. */ - 'ENG_CYLINDER_HEAD_TEMPERATURE:index': { + /** The indexed engine (see note) cylinder head temperature. */ + 'ENG CYLINDER HEAD TEMPERATURE:index': { name: 'ENG CYLINDER HEAD TEMPERATURE:index', - units: 'Rankine', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Exhaust gas temperature for the indexed engine (see note). */ - 'ENG_EXHAUST_GAS_TEMPERATURE:index': { + /** Exhaust gas temperature for the indexed engine (see note). */ + 'ENG EXHAUST GAS TEMPERATURE:index': { name: 'ENG EXHAUST GAS TEMPERATURE:index', - units: 'Rankine', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Governed engine setting exhaust gas temperature for the indexed engine (see note). */ - 'ENG_EXHAUST_GAS_TEMPERATURE_GES:index': { + /** Governed engine setting exhaust gas temperature for the indexed engine (see note). */ + 'ENG EXHAUST GAS TEMPERATURE GES:index': { name: 'ENG EXHAUST GAS TEMPERATURE GES:index', - units: 'Percent Over 100', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Failure flag for the indexed engine (see note) that has failed. */ - 'ENG_FAILED:index': { + /** Failure flag for the indexed engine (see note) that has failed. */ + 'ENG FAILED:index': { name: 'ENG FAILED:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Fuel flow reference in pounds per hour for the indexed engine (see note). */ - 'ENG_FUEL_FLOW_BUG_POSITION:index': { + /** Fuel flow reference in pounds per hour for the indexed engine (see note). */ + 'ENG FUEL FLOW BUG POSITION:index': { name: 'ENG FUEL FLOW BUG POSITION:index', - units: 'Pounds per hour', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Engine fuel flow in gallons per hour for the indexed engine (see note). */ - 'ENG_FUEL_FLOW_GPH:index': { + /** Engine fuel flow in gallons per hour for the indexed engine (see note). */ + 'ENG FUEL FLOW GPH:index': { name: 'ENG FUEL FLOW GPH:index', - units: 'Gallons per hour', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) fuel flow in pounds per hour. */ - 'ENG_FUEL_FLOW_PPH:index': { + /** The indexed engine (see note) fuel flow in pounds per hour. */ + 'ENG FUEL FLOW PPH:index': { name: 'ENG FUEL FLOW PPH:index', units: 'Pounds per hour', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Engine fuel flow in pounds per hour. - Deprecated in favour of ENG FUEL FLOW PPH. */ - 'ENG_FUEL_FLOW_PPH_SSL:index': { + /** +

Engine fuel flow in pounds per hour.

+

Deprecated in favour of ENG FUEL FLOW PPH.

+ */ + 'ENG FUEL FLOW PPH SSL:index': { name: 'ENG FUEL FLOW PPH SSL:index', units: 'Pounds per hour', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) hydraulic pressure. */ - 'ENG_HYDRAULIC_PRESSURE:index': { + /** The indexed engine (see note) hydraulic pressure. */ + 'ENG HYDRAULIC PRESSURE:index': { name: 'ENG HYDRAULIC PRESSURE:index', - units: 'Pounds per square foot (psf)', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note)hydraulic fluid quantity, as a percentage of total capacity */ - 'ENG_HYDRAULIC_QUANTITY:index': { + /** The indexed engine (see note)hydraulic fluid quantity, as a percentage of total capacity */ + 'ENG HYDRAULIC QUANTITY:index': { name: 'ENG HYDRAULIC QUANTITY:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) manifold pressure. */ - 'ENG_MANIFOLD_PRESSURE:index': { + /** The indexed engine (see note) manifold pressure. */ + 'ENG MANIFOLD PRESSURE:index': { name: 'ENG MANIFOLD PRESSURE:index', - units: 'Inches of mercury (inHg)', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) Maximum rpm. */ - ENG_MAX_RPM: { + /** The indexed engine (see note) Maximum rpm. */ + 'ENG MAX RPM': { name: 'ENG MAX RPM', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) N1 rpm. */ - 'ENG_N1_RPM:index': { + /** The indexed engine (see note) N1 rpm. */ + 'ENG N1 RPM:index': { name: 'ENG N1 RPM:index', - units: 'RPM', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) N2 rpm. */ - 'ENG_N2_RPM:index': { + /** The indexed engine (see note) N2 rpm. */ + 'ENG N2 RPM:index': { name: 'ENG N2 RPM:index', - units: 'RPM', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) oil pressure. */ - 'ENG_OIL_PRESSURE:index': { + /** The indexed engine (see note) oil pressure. */ + 'ENG OIL PRESSURE:index': { name: 'ENG OIL PRESSURE:index', - units: 'pounds per square foot (psf)', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) oil quantity as a percentage of full capacity. */ - 'ENG_OIL_QUANTITY:index': { + /** The indexed engine (see note) oil quantity as a percentage of full capacity. */ + 'ENG OIL QUANTITY:index': { name: 'ENG OIL QUANTITY:index', - units: 'Percent Over 100', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) oil temperature. */ - 'ENG_OIL_TEMPERATURE:index': { + /** The indexed engine (see note) oil temperature. */ + 'ENG OIL TEMPERATURE:index': { name: 'ENG OIL TEMPERATURE:index', - units: 'Rankine', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) on fire state. */ - 'ENG_ON_FIRE:index': { + /** The indexed engine (see note) on fire state. */ + 'ENG ON FIRE:index': { name: 'ENG ON FIRE:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** The indexed engine (see note) pressure ratio. */ - 'ENG_PRESSURE_RATIO:index': { + /** The indexed engine (see note) pressure ratio. */ + 'ENG PRESSURE RATIO:index': { name: 'ENG PRESSURE RATIO:index', - units: 'Ratio', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Engine pressure ratio. Deprecated, do not use! */ - 'ENG_PRESSURE_RATIO_GES:index': { + /** Engine pressure ratio. Deprecated, do not use! */ + 'ENG PRESSURE RATIO GES:index': { name: 'ENG PRESSURE RATIO GES:index', units: 'Scalar', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) percentage maximum rated rpm - used for visual animation. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'ENG_RPM_ANIMATION_PERCENT:index': { + /** +

The indexed engine (see note) percentage maximum rated rpm - used for visual animation.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ENG RPM ANIMATION PERCENT:index': { name: 'ENG RPM ANIMATION PERCENT:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** RPM scalar value. Deprecated, do not use! */ - 'ENG_RPM_SCALER:index': { + /** RPM scalar value. Deprecated, do not use! */ + 'ENG RPM SCALER:index': { name: 'ENG RPM SCALER:index', - units: 'Scalar', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) torque. */ - 'ENG_TORQUE:index': { + /** The indexed engine (see note) torque. */ + 'ENG TORQUE:index': { name: 'ENG TORQUE:index', - units: 'Foot pounds', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) vibration. */ - 'ENG_VIBRATION:index': { + /** The indexed engine (see note) vibration. */ + 'ENG VIBRATION:index': { name: 'ENG VIBRATION:index', - units: 'Number', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Estimated fuel flow to the indexed engine (see note) at cruise speed. */ - 'ESTIMATED_FUEL_FLOW:index': { + /** Estimated fuel flow to the indexed engine (see note) at cruise speed. */ + 'ESTIMATED FUEL FLOW:index': { name: 'ESTIMATED FUEL FLOW:index', units: 'Pounds per hour', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Full throttle thrust to weight ratio */ - FULL_THROTTLE_THRUST_TO_WEIGHT_RATIO: { + 'FULL THROTTLE THRUST TO WEIGHT RATIO': { name: 'FULL THROTTLE THRUST TO WEIGHT RATIO', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) anti-ice switch state - 0 (FALSE) is off and 1 (TRUE) is on. */ - 'GENERAL_ENG_ANTI_ICE_POSITION:index': { + /** The indexed engine (see note) anti-ice switch state - 0 (FALSE) is off and 1 (TRUE) is on. */ + 'GENERAL ENG ANTI ICE POSITION:index': { name: 'GENERAL ENG ANTI ICE POSITION:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Set the indexed engine (see note) combustion flag to TRUE or FALSE. Note that this will not only stop all combustion, but it will also set the engine RPM to 0, regardless of the actual state of the simulation. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'GENERAL_ENG_COMBUSTION:index': { + /** +

Set the indexed engine (see note) combustion flag to TRUE or FALSE. Note that this will not only stop all combustion, but it will also set the engine RPM to 0, regardless of the actual state of the simulation.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GENERAL ENG COMBUSTION:index': { name: 'GENERAL ENG COMBUSTION:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** This SimVar is similar to GENERAL ENG COMBUSTION, in that it can also be used to enable or disable engine combustion. However this SimVar will not interfere with the current state of ths simulation. For example, if the aircraft has a turbine engine with auto_ignition enabled or it's a propeller engine with magnetos, then in the subsequent simulation frames this SimVar may be set to 1 (TRUE) again as the engine restarts automatically. */ - 'GENERAL_ENG_COMBUSTION_EX1:index': { + /** This SimVar is similar to GENERAL ENG COMBUSTION, in that it can also be used to enable or disable engine combustion. However this SimVar will not interfere with the current state of ths simulation. For example, if the aircraft has a turbine engine with auto_ignition enabled or it's a propeller engine with magnetos, then in the subsequent simulation frames this SimVar may be set to 1 (TRUE) again as the engine restarts automatically. */ + 'GENERAL ENG COMBUSTION EX1:index': { name: 'GENERAL ENG COMBUSTION EX1:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Percent of maximum sound being created by the indexed engine (see note). - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'GENERAL_ENG_COMBUSTION_SOUND_PERCENT:index': { + /** +

Percent of maximum sound being created by the indexed engine (see note).

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GENERAL ENG COMBUSTION SOUND PERCENT:index': { name: 'GENERAL ENG COMBUSTION SOUND PERCENT:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent of total damage to the indexed engine (see note). */ - 'GENERAL_ENG_DAMAGE_PERCENT:index': { + /** Percent of total damage to the indexed engine (see note). */ + 'GENERAL ENG DAMAGE PERCENT:index': { name: 'GENERAL ENG DAMAGE PERCENT:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Total elapsed time since the indexed engine (see note) was started. */ - 'GENERAL_ENG_ELAPSED_TIME:index': { + /** Total elapsed time since the indexed engine (see note) was started. */ + 'GENERAL ENG ELAPSED TIME:index': { name: 'GENERAL ENG ELAPSED TIME:index', - units: 'Hours', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) exhaust gas temperature. */ - 'GENERAL_ENG_EXHAUST_GAS_TEMPERATURE:index': { + /** The indexed engine (see note) exhaust gas temperature. */ + 'GENERAL ENG EXHAUST GAS TEMPERATURE:index': { name: 'GENERAL ENG EXHAUST GAS TEMPERATURE:index', - units: 'Rankine', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed engine (see note) fail flag. */ - 'GENERAL_ENG_FAILED:index': { + /** The indexed engine (see note) fail flag. */ + 'GENERAL ENG FAILED:index': { name: 'GENERAL ENG FAILED:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Detects if a fire has been detected in an indexed engine (see note) or not. If 0 (FALSE) no fire has been detected and if 1 (TRUE) then it has. */ - 'GENERAL_ENG_FIRE_DETECTED:index': { + /** Detects if a fire has been detected in an indexed engine (see note) or not. If 0 (FALSE) no fire has been detected and if 1 (TRUE) then it has. */ + 'GENERAL ENG FIRE DETECTED:index': { name: 'GENERAL ENG FIRE DETECTED:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** The indexed engine (see note) fuel pressure. */ - 'GENERAL_ENG_FUEL_PRESSURE:index': { + /** The indexed engine (see note) fuel pressure. */ + 'GENERAL ENG FUEL PRESSURE:index': { name: 'GENERAL ENG FUEL PRESSURE:index', - units: 'Pounds per square inch (psi', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Whether the indexed engine (see note) fuel pump on (1, TRUE) or off (0, FALSE). */ - 'GENERAL_ENG_FUEL_PUMP_ON:index': { + /** Whether the indexed engine (see note) fuel pump on (1, TRUE) or off (0, FALSE). */ + 'GENERAL ENG FUEL PUMP ON:index': { name: 'GENERAL ENG FUEL PUMP ON:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Fuel pump switch state the indexed engine (see note). If 0 (FALSE) the pump is off and if 1 (TRUE) then it is on. */ - 'GENERAL_ENG_FUEL_PUMP_SWITCH:index': { + /** +

Fuel pump switch state the indexed engine (see note). If 0 (FALSE) the pump is off and if 1 (TRUE) then it is on.

+ */ + 'GENERAL ENG FUEL PUMP SWITCH:index': { name: 'GENERAL ENG FUEL PUMP SWITCH:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Equivalent to GENERAL ENG FUEL PUMP SWITCH but differentiates between ON and AUTO */ - 'GENERAL_ENG_FUEL_PUMP_SWITCH_EX1:index': { + /** Equivalent to GENERAL ENG FUEL PUMP SWITCH but differentiates between ON and AUTO */ + 'GENERAL ENG FUEL PUMP SWITCH EX1:index': { name: 'GENERAL ENG FUEL PUMP SWITCH EX1:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** Fuel used since the indexed engine (see note) was last started. */ - 'GENERAL_ENG_FUEL_USED_SINCE_START:index': { + /** Fuel used since the indexed engine (see note) was last started. */ + 'GENERAL ENG FUEL USED SINCE START:index': { name: 'GENERAL ENG FUEL USED SINCE START:index', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Fuel valve state for the indexed engine (see note). If 0 (FALSE) then the valve is closed and if 1 (TRUE) then it is open. */ - 'GENERAL_ENG_FUEL_VALVE:index': { + /** +

Fuel valve state for the indexed engine (see note). If 0 (FALSE) then the valve is closed and if 1 (TRUE) then it is open.

+ */ + 'GENERAL ENG FUEL VALVE:index': { name: 'GENERAL ENG FUEL VALVE:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Settable alternator (generator) on/off switch for the indexed engine (see note). */ - 'GENERAL_ENG_GENERATOR_ACTIVE:index': { + /** Settable alternator (generator) on/off switch for the indexed engine (see note). */ + 'GENERAL ENG GENERATOR ACTIVE:index': { name: 'GENERAL ENG GENERATOR ACTIVE:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** Alternator (generator) on/off switch state for the indexed engine (see note). */ - 'GENERAL_ENG_GENERATOR_SWITCH:index': { + /** Alternator (generator) on/off switch state for the indexed engine (see note). */ + 'GENERAL ENG GENERATOR SWITCH:index': { name: 'GENERAL ENG GENERATOR SWITCH:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** This can be used to find the time since the indexed engine (see note) started running. Similar to ElapsedTachometerTime, this records the time the engine has been running, but instead of taking a % of the time based on the Pct/RPM this takes the full time, but only if a threshold RPM/speed is reached. You can set the thresholds using the accumulated_time_hobbs_min_pct_rpm - and accumulated_time_hobbs_min_knots parameters in the [GENERALENGINEDATA] section of the engines.cfg file. */ - 'GENERAL_ENG_HOBBS_ELAPSED_TIME:index': { + /** This can be used to find the time since the indexed engine (see note) started running. Similar to ElapsedTachometerTime, this records the time the engine has been running, but instead of taking a % of the time based on the Pct/RPM this takes the full time, but only if a threshold RPM/speed is reached. You can set the thresholds using the accumulated_time_hobbs_min_pct_rpm
+ and accumulated_time_hobbs_min_knots parameters in the [GENERALENGINEDATA] section of the engines.cfg file. */ + 'GENERAL ENG HOBBS ELAPSED TIME:index': { name: 'GENERAL ENG HOBBS ELAPSED TIME:index', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The alternator switch for a specific engine. Requires an engine index (1 - 4) when used. */ - GENERAL_ENG_MASTER_ALTERNATOR: { + 'GENERAL ENG MASTER ALTERNATOR': { name: 'GENERAL ENG MASTER ALTERNATOR', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Maximum attained rpm for the indexed engine (see note). */ - 'GENERAL_ENG_MAX_REACHED_RPM:index': { + /** Maximum attained rpm for the indexed engine (see note). */ + 'GENERAL ENG MAX REACHED RPM:index': { name: 'GENERAL ENG MAX REACHED RPM:index', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent of max mixture lever position for the indexed engine (see note). */ - 'GENERAL_ENG_MIXTURE_LEVER_POSITION:index': { + /** +

Percent of max mixture lever position for the indexed engine (see note).

+ */ + 'GENERAL ENG MIXTURE LEVER POSITION:index': { name: 'GENERAL ENG MIXTURE LEVER POSITION:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Percent of max oil capacity leaked for the indexed engine (see note). */ - 'GENERAL_ENG_OIL_LEAKED_PERCENT:index': { + /** Percent of max oil capacity leaked for the indexed engine (see note). */ + 'GENERAL ENG OIL LEAKED PERCENT:index': { name: 'GENERAL ENG OIL LEAKED PERCENT:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) oil pressure. */ - 'GENERAL_ENG_OIL_PRESSURE:index': { + /** The indexed engine (see note) oil pressure. */ + 'GENERAL ENG OIL PRESSURE:index': { name: 'GENERAL ENG OIL PRESSURE:index', - units: 'Psf', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed engine (see note) oil temperature. */ - 'GENERAL_ENG_OIL_TEMPERATURE:index': { + /** The indexed engine (see note) oil temperature. */ + 'GENERAL ENG OIL TEMPERATURE:index': { name: 'GENERAL ENG OIL TEMPERATURE:index', units: 'Rankine', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Percent of max rated rpm for the indexed engine (see note). - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'GENERAL_ENG_PCT_MAX_RPM:index': { + /** +

Percent of max rated rpm for the indexed engine (see note).

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GENERAL ENG PCT MAX RPM:index': { name: 'GENERAL ENG PCT MAX RPM:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Percent of max prop lever position for the indexed engine (see note). */ - 'GENERAL_ENG_PROPELLER_LEVER_POSITION:index': { + /** +

Percent of max prop lever position for the indexed engine (see note).

+ */ + 'GENERAL ENG PROPELLER LEVER POSITION:index': { name: 'GENERAL ENG PROPELLER LEVER POSITION:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** This will return 1 (TRUE) if the reverse thruster is engaged, or 0 (FALSE) otherwise. */ - GENERAL_ENG_REVERSE_THRUST_ENGAGED: { + 'GENERAL ENG REVERSE THRUST ENGAGED': { name: 'GENERAL ENG REVERSE THRUST ENGAGED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The RPM for an indexed engine (see note). - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'GENERAL_ENG_RPM:index': { + /** +

The RPM for an indexed engine (see note).

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GENERAL ENG RPM:index': { name: 'GENERAL ENG RPM:index', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed engine (see note) starter on/off state. */ - 'GENERAL_ENG_STARTER:index': { + /** The indexed engine (see note) starter on/off state. */ + 'GENERAL ENG STARTER:index': { name: 'GENERAL ENG STARTER:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** True if the indexed engine (see note) starter is active. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'GENERAL_ENG_STARTER_ACTIVE:index': { + /** +

True if the indexed engine (see note) starter is active.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GENERAL ENG STARTER ACTIVE:index': { name: 'GENERAL ENG STARTER ACTIVE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Percent of max throttle position for the indexed engine (see note). */ - 'GENERAL_ENG_THROTTLE_LEVER_POSITION:index': { + /** +

Percent of max throttle position for the indexed engine (see note). The lower limit will be clamped to the value set for min_throttle_limit.

+ */ + 'GENERAL ENG THROTTLE LEVER POSITION:index': { name: 'GENERAL ENG THROTTLE LEVER POSITION:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Current mode of the managed throttle for the indexed engine (see note). */ - 'GENERAL_ENG_THROTTLE_MANAGED_MODE:index': { + /** Current mode of the managed throttle for the indexed engine (see note). */ + 'GENERAL ENG THROTTLE MANAGED MODE:index': { name: 'GENERAL ENG THROTTLE MANAGED MODE:index', - units: 'Number', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Aircraft master ignition switch (grounds all engines magnetos). */ - MASTER_IGNITION_SWITCH: { + 'MASTER IGNITION SWITCH': { name: 'MASTER IGNITION SWITCH', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** The maximum EGT, as set using the egt_peak_temperature parameter in the engines.cfg file. */ - MAX_EGT: { + /** The maximum EGT, as set using the egt_peak_temperature parameter in the engines.cfg file. */ + 'MAX EGT': { name: 'MAX EGT', units: 'Rankine', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The maximum oil temperature, as set using the parameter oil_temp_heating_constant in the engines.cfg file. */ - MAX_OIL_TEMPERATURE: { + /** The maximum oil temperature, as set using the parameter oil_temp_heating_constant in the engines.cfg file. */ + 'MAX OIL TEMPERATURE': { name: 'MAX OIL TEMPERATURE', units: 'Rankine', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Maximum rated rpm for the indexed engine (see note). */ - MAX_RATED_ENGINE_RPM: { + /** Maximum rated rpm for the indexed engine (see note). */ + 'MAX RATED ENGINE RPM': { name: 'MAX RATED ENGINE RPM', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Number of engines (minimum 0, maximum 4) */ - NUMBER_OF_ENGINES: { + 'NUMBER OF ENGINES': { name: 'NUMBER OF ENGINES', - units: 'Number', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, do not use! */ - OIL_AMOUNT: { + /** Deprecated, do not use! */ + 'OIL AMOUNT': { name: 'OIL AMOUNT', units: 'FS7 Oil Quantity', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Auto-feather arming switch for the indexed engine (see note). Please see the Note On Autofeathering for more information. */ - 'PANEL_AUTO_FEATHER_SWITCH:index': { + /** Auto-feather arming switch for the indexed engine (see note). Please see the Note On Autofeathering for more information. */ + 'PANEL AUTO FEATHER SWITCH:index': { name: 'PANEL AUTO FEATHER SWITCH:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** True if prop auto cruise active */ - PROP_AUTO_CRUISE_ACTIVE: { + 'PROP AUTO CRUISE ACTIVE': { name: 'PROP AUTO CRUISE ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Auto-feather armed state for the indexed engine (see note). */ - 'PROP_AUTO_FEATHER_ARMED:index': { + /** Auto-feather armed state for the indexed engine (see note). */ + 'PROP AUTO FEATHER ARMED:index': { name: 'PROP AUTO FEATHER ARMED:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** The "prop beta" is the pitch of the blades of the propeller, and this can be used to retrieve the current pitch setting, per indexed engine (see note). */ - 'PROP_BETA:index': { + /** The "prop beta" is the pitch of the blades of the propeller, and this can be used to retrieve the current pitch setting, per indexed engine (see note). */ + 'PROP BETA:index': { name: 'PROP BETA:index', - units: 'Radians', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This can be used to enable the propeller forced beta mode (1, TRUE) or disable it (0, FALSE), when being written to. When being read from, it will return TRUE (1) if the forced beta mode is enabled or FALSE (0) if it isn't. When enabled, the PROP BETA FORCED POSITION value will be used to drive the prop beta, while the internal coded simulation logic is used when this is disabled. */ - PROP_BETA_FORCED_ACTIVE: { + /** This can be used to enable the propeller forced beta mode (1, TRUE) or disable it (0, FALSE), when being written to. When being read from, it will return TRUE (1) if the forced beta mode is enabled or FALSE (0) if it isn't. When enabled, the PROP BETA FORCED POSITION value will be used to drive the prop beta, while the internal coded simulation logic is used when this is disabled. */ + 'PROP BETA FORCED ACTIVE': { name: 'PROP BETA FORCED ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Get or set the beta at which the prop is forced. Only valid when PROP BETA FORCED ACTIVE is TRUE (1). */ - PROP_BETA_FORCED_POSITION: { + /** Get or set the beta at which the prop is forced. Only valid when PROP BETA FORCED ACTIVE is TRUE (1). */ + 'PROP BETA FORCED POSITION': { name: 'PROP BETA FORCED POSITION', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The "prop beta" is the pitch of the blades of the propeller. This retrieves the maximum possible pitch value for all engines. */ - PROP_BETA_MAX: { + /** The "prop beta" is the pitch of the blades of the propeller. This retrieves the maximum possible pitch value for all engines. */ + 'PROP BETA MAX': { name: 'PROP BETA MAX', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The "prop beta" is the pitch of the blades of the propeller. This retrieves the minimum possible pitch value for all engines. */ - PROP_BETA_MIN: { + /** The "prop beta" is the pitch of the blades of the propeller. This retrieves the minimum possible pitch value for all engines. */ + 'PROP BETA MIN': { name: 'PROP BETA MIN', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The "prop beta" is the pitch of the blades of the propeller. This retrieves the minimum possible pitch value when the propeller is in reverse for all engines. */ - PROP_BETA_MIN_REVERSE: { + /** The "prop beta" is the pitch of the blades of the propeller. This retrieves the minimum possible pitch value when the propeller is in reverse for all engines. */ + 'PROP BETA MIN REVERSE': { name: 'PROP BETA MIN REVERSE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** True if prop deice switch on for the indexed engine (see note). */ - 'PROP_DEICE_SWITCH:index': { + /** True if prop deice switch on for the indexed engine (see note). */ + 'PROP DEICE SWITCH:index': { name: 'PROP DEICE SWITCH:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** This will return the feathered state of the propeller for an indexed engine (see note). The state is either feathered (true) or not (false). */ - 'PROP_FEATHERED:index': { + /** This will return the feathered state of the propeller for an indexed engine (see note). The state is either feathered (true) or not (false). */ + 'PROP FEATHERED:index': { name: 'PROP FEATHERED:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Feathering inhibit flag for the indexed engine (see note). */ - 'PROP_FEATHERING_INHIBIT:index': { + /** Feathering inhibit flag for the indexed engine (see note). */ + 'PROP FEATHERING INHIBIT:index': { name: 'PROP FEATHERING INHIBIT:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Prop feather switch for the indexed engine (see note). */ - 'PROP_FEATHER_SWITCH:index': { + /** Prop feather switch for the indexed engine (see note). */ + 'PROP FEATHER SWITCH:index': { name: 'PROP FEATHER SWITCH:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Percent of max rated rpm for the indexed engine (see note). - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'PROP_MAX_RPM_PERCENT:index': { + /** +

Percent of max rated rpm for the indexed engine (see note).

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'PROP MAX RPM PERCENT:index': { name: 'PROP MAX RPM PERCENT:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Prop rotation angle. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - PROP_ROTATION_ANGLE: { + /** +

Prop rotation angle.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'PROP ROTATION ANGLE': { name: 'PROP ROTATION ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Propeller rpm for the indexed engine (see note). */ - 'PROP_RPM:index': { + /** Propeller rpm for the indexed engine (see note). */ + 'PROP RPM:index': { name: 'PROP RPM:index', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** True if prop sync is active the indexed engine (see note). */ - 'PROP_SYNC_ACTIVE:index': { + /** True if prop sync is active the indexed engine (see note). */ + 'PROP SYNC ACTIVE:index': { name: 'PROP SYNC ACTIVE:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Corrected prop correction input on slaved engine for the indexed engine (see note). */ - 'PROP_SYNC_DELTA_LEVER:index': { + /** Corrected prop correction input on slaved engine for the indexed engine (see note). */ + 'PROP SYNC DELTA LEVER:index': { name: 'PROP SYNC DELTA LEVER:index', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Propeller thrust for the indexed engine (see note). - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'PROP_THRUST:index': { + /** +

Propeller thrust for the indexed engine (see note).

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'PROP THRUST:index': { name: 'PROP THRUST:index', - units: 'Pounds', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, do not use! */ - PROPELLER_ADVANCED_SELECTION: { + /** Deprecated, do not use! */ + 'PROPELLER ADVANCED SELECTION': { name: 'PROPELLER ADVANCED SELECTION', - units: 'Enum', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** This checks if the shutoff valve to the engine has been pulled (true) or not (false). When pulled piston engines will be blocked from getting any fuel. */ - SHUTOFF_VALVE_PULLED: { + 'SHUTOFF VALVE PULLED': { name: 'SHUTOFF VALVE PULLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Percent throttle defining lower limit (negative for reverse thrust equipped airplanes). */ - THROTTLE_LOWER_LIMIT: { + /** Percent throttle defining lower limit (negative for reverse thrust equipped airplanes). This will be the value defined for the min_throttle_limit parameter. */ + 'THROTTLE LOWER LIMIT': { name: 'THROTTLE LOWER LIMIT', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Afterburner state for the indexed engine (see note). - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'TURB_ENG_AFTERBURNER:index': { + /** +

Afterburner state for the indexed engine (see note).

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'TURB ENG AFTERBURNER:index': { name: 'TURB ENG AFTERBURNER:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The percentage that the afterburner is running at. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'TURB_ENG_AFTERBURNER_PCT_ACTIVE:index': { + /** +

The percentage that the afterburner is running at.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'TURB ENG AFTERBURNER PCT ACTIVE:index': { name: 'TURB ENG AFTERBURNER PCT ACTIVE:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The stage of the afterburner, or 0 if the afterburner is not active. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'TURB_ENG_AFTERBURNER_STAGE_ACTIVE:index': { + /** +

The stage of the afterburner, or 0 if the afterburner is not active.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'TURB ENG AFTERBURNER STAGE ACTIVE:index': { name: 'TURB ENG AFTERBURNER STAGE ACTIVE:index', - units: 'Number', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Bleed air pressure for the indexed engine (see note). */ - 'TURB_ENG_BLEED_AIR:index': { + /** Bleed air pressure for the indexed engine (see note). */ + 'TURB ENG BLEED AIR:index': { name: 'TURB ENG BLEED AIR:index', units: 'Pounds per square inch (psi', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Effective commanded N1 for the indexed turbine engine (see note). */ - 'TURB_ENG_COMMANDED_N1:index': { + /** +

Effective commanded N1 for the indexed turbine engine (see note).

+ */ + 'TURB ENG COMMANDED N1:index': { name: 'TURB ENG COMMANDED N1:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** When the throttle is on idle position, this sets the condition levers to one of 3 positions to define the idle N1 target for the indexed engine (see note): - - Down position is the cut-off position that cuts the fuel to the engine, effectively shutting down the engine. - Middle position requires N1 to reach the low idle value when throttle is in idle position (low idle value can be checked using the TURB_ENG_LOW_IDLE SimVar). - High position requires N1 to reach the high idle value when throttle is in idle position (high idle value can be checked using the TURB_ENG_HIGH_IDLE SimVar). - - Note that this option requires several settings from the engines.cfg file to be set to specific values before working correctly: - - DisableMixtureControls needs to be set to 1 (TRUE). - tp_idle_range should be set to 0 (since there is no mixture setting). - idle_fuel_flow and idle_high_fuel_flow must be set to the same value (since there is no mixture setting to induce a variation between the 2). - low_idle_n1 and high_idle_n1 to be correctly set. */ - 'TURB_ENG_CONDITION_LEVER_POSITION:index': { + /** +

When the throttle is on idle position, this sets the condition levers to one of 3 positions to define the idle N1 target for the indexed engine (see note):

+
    +
  • Down position is the cut-off position that cuts the fuel to the engine, effectively shutting down the engine.
    • +
  • Middle position requires N1 to reach the low idle value when throttle is in idle position (low idle value can be checked using the TURB_ENG_LOW_IDLE SimVar).
    • +
  • High position requires N1 to reach the high idle value when throttle is in idle position (high idle value can be checked using the TURB_ENG_HIGH_IDLE SimVar).
    • +
+

Note that this option requires several settings from the engines.cfg file to be set to specific values before working correctly:

+ + */ + 'TURB ENG CONDITION LEVER POSITION:index': { name: 'TURB ENG CONDITION LEVER POSITION:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** Corrected fuel flow for the indexed engine (see note). */ - 'TURB_ENG_CORRECTED_FF:index': { + /** Corrected fuel flow for the indexed engine (see note). */ + 'TURB ENG CORRECTED FF:index': { name: 'TURB ENG CORRECTED FF:index', - units: 'Pounds per hour', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed turbine engine (see note) corrected N1. */ - 'TURB_ENG_CORRECTED_N1:index': { + /** +

The indexed turbine engine (see note) corrected N1.

+ */ + 'TURB ENG CORRECTED N1:index': { name: 'TURB ENG CORRECTED N1:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed turbine engine (see note) corrected N2. */ - 'TURB_ENG_CORRECTED_N2:index': { + /** +

The indexed turbine engine (see note) corrected N2.

+ */ + 'TURB ENG CORRECTED N2:index': { name: 'TURB ENG CORRECTED N2:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The amount of free torque for the indexed turbine engine (see note). */ - 'TURB_ENG_FREE_TURBINE_TORQUE:index': { + /** The amount of free torque for the indexed turbine engine (see note). */ + 'TURB ENG FREE TURBINE TORQUE:index': { name: 'TURB ENG FREE TURBINE TORQUE:index', - units: 'Foot Pound', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** True if fuel is available for the indexed engine (see note). */ - 'TURB_ENG_FUEL_AVAILABLE:index': { + /** True if fuel is available for the indexed engine (see note). */ + 'TURB ENG FUEL AVAILABLE:index': { name: 'TURB ENG FUEL AVAILABLE:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** This is used to control the fuel efficiency loss of the indexed engine, from 0 - no fuel efficiency loss - to 100 - double the fuel consumption. */ - 'TURB_ENG_FUEL_EFFICIENCY_LOSS:index': { + 'TURB ENG FUEL EFFICIENCY LOSS:index': { name: 'TURB ENG FUEL EFFICIENCY LOSS:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed engine (see note) fuel flow rate. */ - 'TURB_ENG_FUEL_FLOW_PPH:index': { + /** The indexed engine (see note) fuel flow rate. */ + 'TURB ENG FUEL FLOW PPH:index': { name: 'TURB ENG FUEL FLOW PPH:index', - units: 'Pounds per hour', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Retrieves the high idle N1 value to be reached by the the indexed turboprop engine (see note) with throttle in idle position and condition lever in high idle position (condition lever position can be checked or set using the TURB_ENG_CONDITION_LEVER_POSITION SimVar). */ - 'TURB_ENG_HIGH_IDLE:index': { + /** Retrieves the high idle N1 value to be reached by the the indexed turboprop engine (see note) with throttle in idle position and condition lever in high idle position (condition lever position can be checked or set using the TURB_ENG_CONDITION_LEVER_POSITION SimVar). */ + 'TURB ENG HIGH IDLE:index': { name: 'TURB ENG HIGH IDLE:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** True if the the indexed turbine engine (see note) ignition switch is on. */ - 'TURB_ENG_IGNITION_SWITCH:index': { + /** True if the the indexed turbine engine (see note) ignition switch is on. */ + 'TURB ENG IGNITION SWITCH:index': { name: 'TURB ENG IGNITION SWITCH:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Position of the the indexed turbine engine (see note) Ignition Switch. Similar to TURB_ENG_IGNITION_SWITCH but differentiates between ON and AUTO. */ - 'TURB_ENG_IGNITION_SWITCH_EX1:index': { + /** Position of the the indexed turbine engine (see note) Ignition Switch. Similar to TURB_ENG_IGNITION_SWITCH but differentiates between ON and AUTO. */ + 'TURB ENG IGNITION SWITCH EX1:index': { name: 'TURB ENG IGNITION SWITCH EX1:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Whether or not the ignition system is currently running for the indexed engine (see note). Depends on TURB_ENG_IGNITION_SWITCH_EX1 Enum, the cfg var ignition_auto_type and current state of the plane. */ - 'TURB_ENG_IS_IGNITING:index': { + /** Whether or not the ignition system is currently running for the indexed engine (see note). Depends on TURB_ENG_IGNITION_SWITCH_EX1 Enum, the cfg var ignition_auto_type and current state of the plane. */ + 'TURB ENG IS IGNITING:index': { name: 'TURB ENG IS IGNITING:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Retrieve or set the ITT for the indexed engine (see note). */ - 'TURB_ENG_ITT:index': { + /** Retrieve or set the ITT for the indexed engine (see note). */ + 'TURB ENG ITT:index': { name: 'TURB ENG ITT:index', units: 'Rankine', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** This is used to control the ITT cooling efficiency loss of the indexed engine, from 0 - no cooling efficiency loss - to 100 -engine recieves no ITT cooling. */ - 'TURB_ENG_ITT_COOLING_EFFICIENCY_LOSS:index': { + 'TURB ENG ITT COOLING EFFICIENCY LOSS:index': { name: 'TURB ENG ITT COOLING EFFICIENCY LOSS:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed engine (see note) jet thrust. */ - 'TURB_ENG_JET_THRUST:index': { + /** The indexed engine (see note) jet thrust. */ + 'TURB ENG JET THRUST:index': { name: 'TURB ENG JET THRUST:index', - units: 'Pounds', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Retrieves the low idle N1 value to be reached by the the indexed turboprop engine (see note) with throttle in idle position and condition lever in low idle position (condition lever position can be checked or set using the TURB_ENG_CONDITION_LEVER_POSITION SimVar). */ - 'TURB_ENG_LOW_IDLE:index': { + /** Retrieves the low idle N1 value to be reached by the the indexed turboprop engine (see note) with throttle in idle position and condition lever in low idle position (condition lever position can be checked or set using the TURB_ENG_CONDITION_LEVER_POSITION SimVar). */ + 'TURB ENG LOW IDLE:index': { name: 'TURB ENG LOW IDLE:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if the turbine engine master starter switch is on, false otherwise. */ - TURB_ENG_MASTER_STARTER_SWITCH: { + 'TURB ENG MASTER STARTER SWITCH': { name: 'TURB ENG MASTER STARTER SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Percent of max rated torque for the indexed engine (see note). */ - 'TURB_ENG_MAX_TORQUE_PERCENT:index': { + /** Percent of max rated torque for the indexed engine (see note). */ + 'TURB ENG MAX TORQUE PERCENT:index': { name: 'TURB ENG MAX TORQUE PERCENT:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed turbine engine (see note) N1 value. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'TURB_ENG_N1:index': { + /** +

The indexed turbine engine (see note) N1 value.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'TURB ENG N1:index': { name: 'TURB ENG N1:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** This is used to control the N1 loss of the indexed engine, from 0 - no N1 loss - to 100 - 100% N1 loss. */ - 'TURB_ENG_N1_LOSS:index': { + 'TURB ENG N1 LOSS:index': { name: 'TURB ENG N1 LOSS:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed turbine engine (see note) N2 value. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'TURB_ENG_N2:index': { + /** +

The indexed turbine engine (see note) N2 value.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'TURB ENG N2:index': { name: 'TURB ENG N2:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Number of tanks currently being used by the indexed engine (see note). */ - 'TURB_ENG_NUM_TANKS_USED:index': { + /** Number of tanks currently being used by the indexed engine (see note). */ + 'TURB ENG NUM TANKS USED:index': { name: 'TURB ENG NUM TANKS USED:index', - units: 'Number', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) pressure ratio. */ - 'TURB_ENG_PRESSURE_RATIO:index': { + /** The indexed engine (see note) pressure ratio. */ + 'TURB ENG PRESSURE RATIO:index': { name: 'TURB ENG PRESSURE RATIO:index', - units: 'Ratio', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Percent thrust of primary nozzle for the indexed engine (see note). */ - 'TURB_ENG_PRIMARY_NOZZLE_PERCENT:index': { + /** Percent thrust of primary nozzle for the indexed engine (see note). */ + 'TURB ENG PRIMARY NOZZLE PERCENT:index': { name: 'TURB ENG PRIMARY NOZZLE PERCENT:index', - units: 'Percent Over 100', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent thrust reverser nozzles deployed for the indexed engine (see note). - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'TURB_ENG_REVERSE_NOZZLE_PERCENT:index': { + /** +

Percent thrust reverser nozzles deployed for the indexed engine (see note).

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'TURB ENG REVERSE NOZZLE PERCENT:index': { name: 'TURB ENG REVERSE NOZZLE PERCENT:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Fuel tanks used by the indexed engine (see note), one or more of the following bit flags: - - Center 1 Bit 0 - Center 2 Bit 1 - Center 3 Bit 2 - Left Main Bit 3 - Left Aux Bit 4 - Left Tip Bit 5 - Right Main Bit 6 - Right Aux Bit 7 - Right Tip Bit 8 - External 1 Bit 9 - External 2 Bit 10 */ - 'TURB_ENG_TANKS_USED:index': { + /** Fuel tanks used by the indexed engine (see note), one or more of the following bit flags: +
    +
  1. Center 1 Bit 0
    2. +
  2. Center 2 Bit 1
    3. +
  3. Center 3 Bit 2
    4. +
  4. Left Main Bit 3
    5. +
  5. Left Aux Bit 4
    6. +
  6. Left Tip Bit 5
    7. +
  7. Right Main Bit 6
    8. +
  8. Right Aux Bit 7
    9. +
  9. Right Tip Bit 8
    10. +
  10. External 1 Bit 9
    11. +
  11. External 2 Bit 10
    12. +
+ */ + 'TURB ENG TANKS USED:index': { name: 'TURB ENG TANKS USED:index', - units: 'Mask', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Fuel tank selected for the indexed engine (see note). See Fuel Tank Selection for a list of values. */ - 'TURB_ENG_TANK_SELECTOR:index': { + /** Fuel tank selected for the indexed engine (see note). See Fuel Tank Selection for a list of values. */ + 'TURB ENG TANK SELECTOR:index': { name: 'TURB ENG TANK SELECTOR:index', - units: 'Enum', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** The indexed turbine engine (see note) commanded N1 for current throttle position. */ - 'TURB_ENG_THROTTLE_COMMANDED_N1:index': { + /** +

The indexed turbine engine (see note) commanded N1 for current throttle position.

+ */ + 'TURB ENG THROTTLE COMMANDED N1:index': { name: 'TURB ENG THROTTLE COMMANDED N1:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** This can be used to control the thrust efficiency loss of the indexed engine, where a value of 0 is 100% of available thrust, and 100 is 0% available thrust. */ - 'TURB_ENG_THRUST_EFFICIENCY_LOSS:index': { + 'TURB ENG THRUST EFFICIENCY LOSS:index': { name: 'TURB ENG THRUST EFFICIENCY LOSS:index', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed turbine engine (see note) vibration value. */ - 'TURB_ENG_VIBRATION:index': { + /** The indexed turbine engine (see note) vibration value. */ + 'TURB ENG VIBRATION:index': { name: 'TURB ENG VIBRATION:index', - units: 'Number', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Retrieve the itt_peak_temperature as set in the engines.cfg file. */ - TURB_MAX_ITT: { + /** Retrieve the itt_peak_temperature as set in the engines.cfg file. */ + 'TURB MAX ITT': { name: 'TURB MAX ITT', units: 'Rankine', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Carburetor temperature the indexed engine (see note). */ - 'RECIP_CARBURETOR_TEMPERATURE:index': { + /** Carburetor temperature the indexed engine (see note). */ + 'RECIP CARBURETOR TEMPERATURE:index': { name: 'RECIP CARBURETOR TEMPERATURE:index', units: 'Celsius', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Alternate air control the indexed engine (see note). */ - 'RECIP_ENG_ALTERNATE_AIR_POSITION:index': { + /** Alternate air control the indexed engine (see note). */ + 'RECIP ENG ALTERNATE AIR POSITION:index': { name: 'RECIP ENG ALTERNATE AIR POSITION:index', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The maximum quantity of water/methanol mixture in the ADI tank for the indexed engine (see note). This value is set as part of the [ANTIDETONATION_SYSTEM.N] section in the aircraft configuration files. */ - 'RECIP_ENG_ANTIDETONATION_TANK_MAX_QUANTITY:index': { + /** The maximum quantity of water/methanol mixture in the ADI tank for the indexed engine (see note). This value is set as part of the [ANTIDETONATION_SYSTEM.N] section in the aircraft configuration files. */ + 'RECIP ENG ANTIDETONATION TANK MAX QUANTITY:index': { name: 'RECIP ENG ANTIDETONATION TANK MAX QUANTITY:index', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The quantity of water/methanol mixture currently in the ADI tank for the indexed engine (see note). */ - 'RECIP_ENG_ANTIDETONATION_TANK_QUANTITY:index': { + /** The quantity of water/methanol mixture currently in the ADI tank for the indexed engine (see note). */ + 'RECIP ENG ANTIDETONATION TANK QUANTITY:index': { name: 'RECIP ENG ANTIDETONATION TANK QUANTITY:index', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The status of the ADI tank valve for the indexed engine (see note). */ - 'RECIP_ENG_ANTIDETONATION_TANK_VALVE:index': { + /** The status of the ADI tank valve for the indexed engine (see note). */ + 'RECIP ENG ANTIDETONATION TANK VALVE:index': { name: 'RECIP ENG ANTIDETONATION TANK VALVE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** This gives the actual flow rate of the Anti Detonation system for the indexed engine (see note). */ - 'RECIP_ENG_ANTIDETONATION_FLOW_RATE:index': { + /** This gives the actual flow rate of the Anti Detonation system for the indexed engine (see note). */ + 'RECIP ENG ANTIDETONATION FLOW RATE:index': { name: 'RECIP ENG ANTIDETONATION FLOW RATE:index', units: 'Gallons per hour', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Brake power produced by the indexed engine (see note). */ - 'RECIP_ENG_BRAKE_POWER:index': { + /** Brake power produced by the indexed engine (see note). */ + 'RECIP ENG BRAKE POWER:index': { name: 'RECIP ENG BRAKE POWER:index', - units: 'Foot pounds (ftlbs) per second', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Percent coolant available for the indexed engine (see note). */ - 'RECIP_ENG_COOLANT_RESERVOIR_PERCENT:index': { + /** Percent coolant available for the indexed engine (see note). */ + 'RECIP ENG COOLANT RESERVOIR PERCENT:index': { name: 'RECIP ENG COOLANT RESERVOIR PERCENT:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Percent cowl flap opened for the indexed engine (see note). */ - 'RECIP_ENG_COWL_FLAP_POSITION:index': { + /** +

Percent cowl flap opened for the indexed engine (see note).

+ */ + 'RECIP ENG COWL FLAP POSITION:index': { name: 'RECIP ENG COWL FLAP POSITION:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Engine cylinder head temperature for the indexed engine (see note). */ - 'RECIP_ENG_CYLINDER_HEAD_TEMPERATURE:index': { + /** Engine cylinder head temperature for the indexed engine (see note). */ + 'RECIP ENG CYLINDER HEAD TEMPERATURE:index': { name: 'RECIP ENG CYLINDER HEAD TEMPERATURE:index', - units: 'Celsius', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Index high 16 bits is engine number, low16 cylinder number, both indexed from 1. */ - 'RECIP_ENG_CYLINDER_HEALTH:index': { + 'RECIP ENG CYLINDER HEALTH:index': { name: 'RECIP ENG CYLINDER HEALTH:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Set to 1 (TRUE) if the indexed engine (see note) is detonating. */ - 'RECIP_ENG_DETONATING:index': { + /** Set to 1 (TRUE) if the indexed engine (see note) is detonating. */ + 'RECIP ENG DETONATING:index': { name: 'RECIP ENG DETONATING:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Whether emergency boost is active (1, TRUE) or not (0, FALSE) for the indexed engine (see note). */ - 'RECIP_ENG_EMERGENCY_BOOST_ACTIVE:index': { + /** Whether emergency boost is active (1, TRUE) or not (0, FALSE) for the indexed engine (see note). */ + 'RECIP ENG EMERGENCY BOOST ACTIVE:index': { name: 'RECIP ENG EMERGENCY BOOST ACTIVE:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** The elapsed time that emergency boost has been active on the indexed engine (see note). The timer will start when boost is first activated. - IMPORTANT! This timer does not reset. So if you set your time limit in the engines.cfg file to 315s and you spend 2 minutes with boost active, then pull back on the throttle for 1 minute, then engage boost again for 2 minutes, the simulation will consider that you spent 4 minutes with boost active. The 1 minute pause is not taken into account. */ - 'RECIP_ENG_EMERGENCY_BOOST_ELAPSED_TIME:index': { + /** +

The elapsed time that emergency boost has been active on the indexed engine (see note). The timer will start when boost is first activated.

+

IMPORTANT! This timer does not reset. So if you set your time limit in the engines.cfg file to 315s and you spend 2 minutes with boost active, then pull back on the throttle for 1 minute, then engage boost again for 2 minutes, the simulation will consider that you spent 4 minutes with boost active. The 1 minute pause is not taken into account.

+ */ + 'RECIP ENG EMERGENCY BOOST ELAPSED TIME:index': { name: 'RECIP ENG EMERGENCY BOOST ELAPSED TIME:index', - units: 'Hours', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Whether or not the Engine Master switch is active on an indexed engine (see note). */ - 'RECIP_ENG_ENGINE_MASTER_SWITCH:index': { + /** Whether or not the Engine Master switch is active on an indexed engine (see note). */ + 'RECIP ENG ENGINE MASTER SWITCH:index': { name: 'RECIP ENG ENGINE MASTER SWITCH:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** True if fuel is available for the indexed engine (see note). */ - 'RECIP_ENG_FUEL_AVAILABLE:index': { + /** True if fuel is available for the indexed engine (see note). */ + 'RECIP ENG FUEL AVAILABLE:index': { name: 'RECIP ENG FUEL AVAILABLE:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** The indexed engine (see note) fuel flow. */ - 'RECIP_ENG_FUEL_FLOW:index': { + /** The indexed engine (see note) fuel flow. */ + 'RECIP ENG FUEL FLOW:index': { name: 'RECIP ENG FUEL FLOW:index', - units: 'Pounds per hour', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Number of tanks currently being used by the indexed engine (see note). */ - 'RECIP_ENG_FUEL_NUMBER_TANKS_USED:index': { + /** Number of tanks currently being used by the indexed engine (see note). */ + 'RECIP ENG FUEL NUMBER TANKS USED:index': { name: 'RECIP ENG FUEL NUMBER TANKS USED:index', - units: 'Number', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Fuel tanks used by the indexed engine (see note), one or more of the following bit flags: - - Center 1 Bit 0 - Center 2 Bit 1 - Center 3 Bit 2 - Left Main Bit 3 - Left Aux Bit 4 - Left Tip Bit 5 - Right Main Bit 6 - Right Aux Bit 7 - Right Tip Bit 8 - External 1 Bit 9 - External 2 Bit 10 */ - 'RECIP_ENG_FUEL_TANKS_USED:index': { + /** Fuel tanks used by the indexed engine (see note), one or more of the following bit flags: +
    +
  1. Center 1 Bit 0
    2. +
  2. Center 2 Bit 1
    3. +
  3. Center 3 Bit 2
    4. +
  4. Left Main Bit 3
    5. +
  5. Left Aux Bit 4
    6. +
  6. Left Tip Bit 5
    7. +
  7. Right Main Bit 6
    8. +
  8. Right Aux Bit 7
    9. +
  9. Right Tip Bit 8
    10. +
  10. External 1 Bit 9
    11. +
  11. External 2 Bit 10
    12. +
+ */ + 'RECIP ENG FUEL TANKS USED:index': { name: 'RECIP ENG FUEL TANKS USED:index', - units: 'Mask', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** Fuel tank selected for the indexed engine (see note). See Fuel Tank Selection for a list of values. */ - 'RECIP_ENG_FUEL_TANK_SELECTOR:index': { + /** Fuel tank selected for the indexed engine (see note). See Fuel Tank Selection for a list of values. */ + 'RECIP ENG FUEL TANK SELECTOR:index': { name: 'RECIP ENG FUEL TANK SELECTOR:index', - units: 'Enum', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Whether or not the Glow Plug is active on the indexed engine (see note).. */ - 'RECIP_ENG_GLOW_PLUG_ACTIVE:index': { + /** Whether or not the Glow Plug is active on the indexed engine (see note).. */ + 'RECIP ENG GLOW PLUG ACTIVE:index': { name: 'RECIP ENG GLOW PLUG ACTIVE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Left magneto state for the indexed engine (see note). */ - 'RECIP_ENG_LEFT_MAGNETO:index': { + /** +

Left magneto state for the indexed engine (see note).

+ */ + 'RECIP ENG LEFT MAGNETO:index': { name: 'RECIP ENG LEFT MAGNETO:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** The indexed engine (see note) manifold pressure. */ - 'RECIP_ENG_MANIFOLD_PRESSURE:index': { + /** The indexed engine (see note) manifold pressure. */ + 'RECIP ENG MANIFOLD PRESSURE:index': { name: 'RECIP ENG MANIFOLD PRESSURE:index', units: 'Pounds per square inch (psi', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The maximum quantity of nitrous permitted per indexed engine (see note). */ - 'RECIP_ENG_NITROUS_TANK_MAX_QUANTITY:index': { + /** The maximum quantity of nitrous permitted per indexed engine (see note). */ + 'RECIP ENG NITROUS TANK MAX QUANTITY:index': { name: 'RECIP ENG NITROUS TANK MAX QUANTITY:index', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The quantity of nitrous per indexed engine (see note). */ - 'RECIP_ENG_NITROUS_TANK_QUANTITY:index': { + /** The quantity of nitrous per indexed engine (see note). */ + 'RECIP ENG NITROUS TANK QUANTITY:index': { name: 'RECIP ENG NITROUS TANK QUANTITY:index', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The statte of the nitrous tank valve for the indexed engine (see note). Either 1 (TRUE) for open or 0 (FALSE) for closed. */ - RECIP_ENG_NITROUS_TANK_VALVE: { + /** The statte of the nitrous tank valve for the indexed engine (see note). Either 1 (TRUE) for open or 0 (FALSE) for closed. */ + 'RECIP ENG NITROUS TANK VALVE': { name: 'RECIP ENG NITROUS TANK VALVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** The number of cylinders for the indexed engine (see note). */ - 'RECIP_ENG_NUM_CYLINDERS:index': { + /** The number of cylinders for the indexed engine (see note). */ + 'RECIP ENG NUM CYLINDERS:index': { name: 'RECIP ENG NUM CYLINDERS:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The number of cylinders that have failed in the indexed engine (see note). */ - 'RECIP_ENG_NUM_CYLINDERS_FAILED:index': { + /** The number of cylinders that have failed in the indexed engine (see note). */ + 'RECIP ENG NUM CYLINDERS FAILED:index': { name: 'RECIP ENG NUM CYLINDERS FAILED:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) primer state. */ - 'RECIP_ENG_PRIMER:index': { + /** The indexed engine (see note) primer state. */ + 'RECIP ENG PRIMER:index': { name: 'RECIP ENG PRIMER:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** The indexed engine (see note) radiator temperature. */ - 'RECIP_ENG_RADIATOR_TEMPERATURE:index': { + /** The indexed engine (see note) radiator temperature. */ + 'RECIP ENG RADIATOR TEMPERATURE:index': { name: 'RECIP ENG RADIATOR TEMPERATURE:index', - units: 'Celsius', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed engine (see note) right magneto state. */ - 'RECIP_ENG_RIGHT_MAGNETO:index': { + /** +

The indexed engine (see note) right magneto state.

+ */ + 'RECIP ENG RIGHT MAGNETO:index': { name: 'RECIP ENG RIGHT MAGNETO:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** Torque produced by the indexed engine (see note). */ - 'RECIP_ENG_STARTER_TORQUE:index': { + /** Torque produced by the indexed engine (see note). */ + 'RECIP ENG STARTER TORQUE:index': { name: 'RECIP ENG STARTER TORQUE:index', - units: 'Foot pound', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Returns which of the supercharger gears is engaged for the indexed engine (see note). */ - 'RECIP_ENG_SUPERCHARGER_ACTIVE_GEAR:index': { + /** Returns which of the supercharger gears is engaged for the indexed engine (see note). */ + 'RECIP ENG SUPERCHARGER ACTIVE GEAR:index': { name: 'RECIP ENG SUPERCHARGER ACTIVE GEAR:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed engine (see note) turbine inlet temperature. */ - 'RECIP_ENG_TURBINE_INLET_TEMPERATURE:index': { + /** The indexed engine (see note) turbine inlet temperature. */ + 'RECIP ENG TURBINE INLET TEMPERATURE:index': { name: 'RECIP ENG TURBINE INLET TEMPERATURE:index', - units: 'Celsius', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The indexed engine (see note) turbo failed state. */ - 'RECIP_ENG_TURBOCHARGER_FAILED:index': { + /** The indexed engine (see note) turbo failed state. */ + 'RECIP ENG TURBOCHARGER FAILED:index': { name: 'RECIP ENG TURBOCHARGER FAILED:index', - units: 'Bool', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** When the engines.cfg parameter turbocharged is TRUE, this SimVar will return the percentage that the turbo waste gate is closed for the indexed engine (see note). If the turbocharged variable is FALSE and the manifold_pressure_regulator parameter is TRUE, then this will return the percentage that the manifold pressure regulator is closed for the indexed engine. */ - 'RECIP_ENG_WASTEGATE_POSITION:index': { + /** When the engines.cfg parameter turbocharged is TRUE, this SimVar will return the percentage that the turbo waste gate is closed for the indexed engine (see note). If the turbocharged variable is FALSE and the manifold_pressure_regulator parameter is TRUE, then this will return the percentage that the manifold pressure regulator is closed for the indexed engine. */ + 'RECIP ENG WASTEGATE POSITION:index': { name: 'RECIP ENG WASTEGATE POSITION:index', - units: 'Percent', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This will return the cylinder head temperature value set by the cht_heating_constant parameter in the engines.cfg file. */ - RECIP_MAX_CHT: { + /** This will return the cylinder head temperature value set by the cht_heating_constant parameter in the engines.cfg file. */ + 'RECIP MAX CHT': { name: 'RECIP MAX CHT', units: 'Rankine', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Fuel / Air mixture ratio for the indexed engine (see note). */ - 'RECIP_MIXTURE_RATIO:index': { + /** Fuel / Air mixture ratio for the indexed engine (see note). */ + 'RECIP MIXTURE RATIO:index': { name: 'RECIP MIXTURE RATIO:index', units: 'Ratio', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Beta dot */ - BETA_DOT: { + 'BETA DOT': { name: 'BETA DOT', units: 'Radians per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Design decision altitude above mean sea level */ - DECISION_ALTITUDE_MSL: { + 'DECISION ALTITUDE MSL': { name: 'DECISION ALTITUDE MSL', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Design decision height */ - DECISION_HEIGHT: { + 'DECISION HEIGHT': { name: 'DECISION HEIGHT', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This design constant represents the optimal altitude the aircraft should maintain when in cruise. It is derived from the cruise_alt setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default is 1500ft. */ - DESIGN_CRUISE_ALT: { + /** This design constant represents the optimal altitude the aircraft should maintain when in cruise. It is derived from the cruise_alt setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default is 1500ft. */ + 'DESIGN CRUISE ALT': { name: 'DESIGN CRUISE ALT', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This design constant represents the spawn altitude for the aircraft when spawning in cruise. It is derived from the spawn_cruise_altitude setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default is 1500ft. */ - DESIGN_SPAWN_ALTITUDE_CRUISE: { + /** This design constant represents the spawn altitude for the aircraft when spawning in cruise. It is derived from the spawn_cruise_altitude setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default is 1500ft. */ + 'DESIGN SPAWN ALTITUDE CRUISE': { name: 'DESIGN SPAWN ALTITUDE CRUISE', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This design constant represents the spawn altitude for the aircraft when spawning in descent. It is derived from the spawn_descent_altitude setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default is 500ft. */ - DESIGN_SPAWN_ALTITUDE_DESCENT: { + /** This design constant represents the spawn altitude for the aircraft when spawning in descent. It is derived from the spawn_descent_altitude setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default is 500ft. */ + 'DESIGN SPAWN ALTITUDE DESCENT': { name: 'DESIGN SPAWN ALTITUDE DESCENT', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This design constant represents the optimal climb speed for the aircraft. It is derived from the climb_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is -1. */ - DESIGN_SPEED_CLIMB: { + /** This design constant represents the optimal climb speed for the aircraft. It is derived from the climb_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is -1. */ + 'DESIGN SPEED CLIMB': { name: 'DESIGN SPEED CLIMB', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This design constant represents the minimum speed required for aircraft rotation. It is derived from the rotation_speed_min setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is -1. */ - DESIGN_SPEED_MIN_ROTATION: { + /** This design constant represents the minimum speed required for aircraft rotation. It is derived from the rotation_speed_min setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is -1. */ + 'DESIGN SPEED MIN ROTATION': { name: 'DESIGN SPEED MIN ROTATION', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This design constant represents the aircraft ideal cruising speed. It is derived from the cruise_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. The default value is computed an internal function that uses the estimated cruise altitude and estimated cruise percent power, according of the engine type, the number of engines, the density, the wing area and some drag parameters. Normally this value is set in the CFG file and the default value is never used. */ - DESIGN_SPEED_VC: { + /** This design constant represents the aircraft ideal cruising speed. It is derived from the cruise_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. The default value is computed an internal function that uses the estimated cruise altitude and estimated cruise percent power, according of the engine type, the number of engines, the density, the wing area and some drag parameters. Normally this value is set in the CFG file and the default value is never used. */ + 'DESIGN SPEED VC': { name: 'DESIGN SPEED VC', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This design constant represents the the stall speed when flaps are fully extended. It is derived from the full_flaps_stall_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is 0.8 x VS. */ - DESIGN_SPEED_VS0: { + /** This design constant represents the the stall speed when flaps are fully extended. It is derived from the full_flaps_stall_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is 0.8 x VS. */ + 'DESIGN SPEED VS0': { name: 'DESIGN SPEED VS0', units: 'kias', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This design constant represents the stall speed when flaps are fully retracted. It is derived from the flaps_up_stall_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is 0. */ - DESIGN_SPEED_VS1: { + /** This design constant represents the stall speed when flaps are fully retracted. It is derived from the flaps_up_stall_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. Default value is 0. */ + 'DESIGN SPEED VS1': { name: 'DESIGN SPEED VS1', units: 'kias', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This design constant represents the aircraft ideal takoff speed. It is derived from the takeoff_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. */ - DESIGN_TAKEOFF_SPEED: { + /** This design constant represents the aircraft ideal takoff speed. It is derived from the takeoff_speed setting in the [REFERENCE SPEEDS] section of the flightmodel.cfg. */ + 'DESIGN TAKEOFF SPEED': { name: 'DESIGN TAKEOFF SPEED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Dynamic pressure */ - DYNAMIC_PRESSURE: { + 'DYNAMIC PRESSURE': { name: 'DYNAMIC PRESSURE', units: 'Pounds per square foot (psf)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Estimated cruise speed */ - ESTIMATED_CRUISE_SPEED: { + 'ESTIMATED CRUISE SPEED': { name: 'ESTIMATED CRUISE SPEED', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Current g force */ - G_FORCE: { + 'G FORCE': { name: 'G FORCE', units: 'GForce', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This returns the setting of the G-limiter, as set using the GLimiterSetting parameter. */ - G_LIMITER_SETTING: { + /** This returns the setting of the G-limiter, as set using the GLimiterSetting parameter. */ + 'G LIMITER SETTING': { name: 'G LIMITER SETTING', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Angle of attack */ - INCIDENCE_ALPHA: { + 'INCIDENCE ALPHA': { name: 'INCIDENCE ALPHA', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Sideslip angle */ - INCIDENCE_BETA: { + 'INCIDENCE BETA': { name: 'INCIDENCE BETA', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if the aircraft is a taildragger */ - IS_TAIL_DRAGGER: { + 'IS TAIL DRAGGER': { name: 'IS TAIL DRAGGER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Linear CL alpha */ - LINEAR_CL_ALPHA: { + 'LINEAR CL ALPHA': { name: 'LINEAR CL ALPHA', units: 'Per radian', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Maximum design mach */ - MACH_MAX_OPERATE: { + 'MACH MAX OPERATE': { name: 'MACH MAX OPERATE', units: 'Mach', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Maximum G force attained */ - MAX_G_FORCE: { + 'MAX G FORCE': { name: 'MAX G FORCE', units: 'Gforce', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Minimum drag velocity, -in clean, with no input and no gears, when at 10000ft. */ - MIN_DRAG_VELOCITY: { + /** Minimum drag velocity, in clean, with no input and no gears, when at 10000ft. */ + 'MIN DRAG VELOCITY': { name: 'MIN DRAG VELOCITY', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Minimum G force attained */ - MIN_G_FORCE: { + 'MIN G FORCE': { name: 'MIN G FORCE', units: 'Gforce', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, do not use! */ - SEMIBODY_LOADFACTOR_X: { + /** Deprecated, do not use! */ + 'SEMIBODY LOADFACTOR X': { name: 'SEMIBODY LOADFACTOR X', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Acceleration along the axis Y divided by the gravity constant g (usually around 9.81m.s²) */ - SEMIBODY_LOADFACTOR_Y: { + 'SEMIBODY LOADFACTOR Y': { name: 'SEMIBODY LOADFACTOR Y', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Derivative of SEMIBODY LOADFACTOR Y in relation to time. */ - SEMIBODY_LOADFACTOR_YDOT: { + /** Derivative of SEMIBODY LOADFACTOR Y in relation to time. */ + 'SEMIBODY LOADFACTOR YDOT': { name: 'SEMIBODY LOADFACTOR YDOT', units: 'Per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, do not use! */ - SEMIBODY_LOADFACTOR_Z: { + /** Deprecated, do not use! */ + 'SEMIBODY LOADFACTOR Z': { name: 'SEMIBODY LOADFACTOR Z', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Sigma sqrt */ - SIGMA_SQRT: { + 'SIGMA SQRT': { name: 'SIGMA SQRT', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Simulated radius */ - SIMULATED_RADIUS: { + 'SIMULATED RADIUS': { name: 'SIMULATED RADIUS', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The angle of attack which produces the maximum lift coefficient before entering into stall conditions. */ - STALL_ALPHA: { + 'STALL ALPHA': { name: 'STALL ALPHA', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The angle at which static pitch stability is achieved. */ - STATIC_PITCH: { + 'STATIC PITCH': { name: 'STATIC PITCH', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** the typical (normal) descent rate for the aircraft. */ - TYPICAL_DESCENT_RATE: { + 'TYPICAL DESCENT RATE': { name: 'TYPICAL DESCENT RATE', units: 'Feet (ft) per minute', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Total wing area */ - WING_AREA: { + 'WING AREA': { name: 'WING AREA', units: 'Square feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The current wing flex. Different values can be set for each wing (for example, during banking). Set an index of 1 for the left wing, and 2 for the right wing. */ - 'WING_FLEX_PCT:index': { + 'WING FLEX PCT:index': { name: 'WING FLEX PCT:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Total wing span */ - WING_SPAN: { + 'WING SPAN': { name: 'WING SPAN', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The yaw string angle. Yaw strings are attached to gliders as visible indicators of the yaw angle. An animation of this is not implemented in ESP. */ - YAW_STRING_ANGLE: { + 'YAW STRING ANGLE': { name: 'YAW STRING ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Yaw string angle as a percentage */ - YAW_STRING_PCT_EXTENDED: { + 'YAW STRING PCT EXTENDED': { name: 'YAW STRING PCT EXTENDED', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The angle of attack at which the wing has zero lift. */ - ZERO_LIFT_ALPHA: { + 'ZERO LIFT ALPHA': { name: 'ZERO LIFT ALPHA', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Most backward authorized position of the CG according to the POH. - NOTE: This is only valid for airplanes. */ - CG_AFT_LIMIT: { + /** +

Most backward authorized position of the CG according to the POH.

+

NOTE: This is only valid for airplanes.

+ */ + 'CG AFT LIMIT': { name: 'CG AFT LIMIT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The longitudinal CG position relative to the Reference Datum Position. - NOTE: This is only valid for helicopters. */ - CG_FEET: { + /** +

The longitudinal CG position relative to the Reference Datum Position.

+

NOTE: This is only valid for helicopters.

+ */ + 'CG FEET': { name: 'CG FEET', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The aft -CG -limit position relative to the Reference Datum Position. - NOTE: This is only valid for helicopters. */ - CG_FEET_AFT_LIMIT: { + /** +

The aft CG limit position relative to the Reference Datum Position.

+

NOTE: This is only valid for helicopters.

+ */ + 'CG FEET AFT LIMIT': { name: 'CG FEET AFT LIMIT', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The lateral -CG position relative to the Reference Datum Position. - NOTE: This is only valid for helicopters. */ - CG_FEET_LATERAL: { + /** +

The lateral CG position relative to the Reference Datum Position.

+

NOTE: This is only valid for helicopters.

+ */ + 'CG FEET LATERAL': { name: 'CG FEET LATERAL', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The left hand lateral -CG position relative to the Reference Datum Position. - NOTE: This is only valid for helicopters. */ - CG_FEET_LATERAL_LEFT_LIMIT: { + /** +

The left hand lateral CG position relative to the Reference Datum Position.

+

NOTE: This is only valid for helicopters.

+ */ + 'CG FEET LATERAL LEFT LIMIT': { name: 'CG FEET LATERAL LEFT LIMIT', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The right hand lateral -CG position relative to the Reference Datum Position. - NOTE: This is only valid for helicopters. */ - CG_FEET_LATERAL_RIGHT_LIMIT: { + /** +

The right hand lateral CG position relative to the Reference Datum Position.

+

NOTE: This is only valid for helicopters.

+ */ + 'CG FEET LATERAL RIGHT LIMIT': { name: 'CG FEET LATERAL RIGHT LIMIT', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The forward -CG -limit position relative to the Reference Datum Position. - NOTE: This is only valid for helicopters. */ - CG_FEET_FWD_LIMIT: { + /** +

The forward CG limit position relative to the Reference Datum Position.

+

NOTE: This is only valid for helicopters.

+ */ + 'CG FEET FWD LIMIT': { name: 'CG FEET FWD LIMIT', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Most forward authorized position of the CG according to the POH. - NOTE: This is only valid for airplanes. */ - CG_FWD_LIMIT: { + /** +

Most forward authorized position of the CG according to the POH.

+

NOTE: This is only valid for airplanes.

+ */ + 'CG FWD LIMIT': { name: 'CG FWD LIMIT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, do not use! */ - CG_MAX_MACH: { + /** Deprecated, do not use! */ + 'CG MAX MACH': { name: 'CG MAX MACH', units: 'Mach', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, do not use! */ - CG_MIN_MACH: { + /** Deprecated, do not use! */ + 'CG MIN MACH': { name: 'CG MIN MACH', units: 'Mach', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Longitudinal CG position as a percent of reference Chord. - NOTE: This is only valid for airplanes. */ - CG_PERCENT: { + /** +

Longitudinal CG position as a percent of reference Chord.

+

NOTE: This is only valid for airplanes.

+ */ + 'CG PERCENT': { name: 'CG PERCENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Lateral CG position as a percent of reference Chord. - NOTE: This is only valid for airplanes. */ - CG_PERCENT_LATERAL: { + /** +

Lateral CG position as a percent of reference Chord.

+

NOTE: This is only valid for airplanes.

+ */ + 'CG PERCENT LATERAL': { name: 'CG PERCENT LATERAL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Static CG position with reference to the ground. - NOTE: This is only valid for airplanes. */ - STATIC_CG_TO_GROUND: { + /** +

Static CG position with reference to the ground.

+

NOTE: This is only valid for airplanes.

+ */ + 'STATIC CG TO GROUND': { name: 'STATIC CG TO GROUND', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point orientation: Bank */ - INTERACTIVE_POINT_BANK: { + 'INTERACTIVE POINT BANK': { name: 'INTERACTIVE POINT BANK', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point orientation: Heading */ - INTERACTIVE_POINT_HEADING: { + 'INTERACTIVE POINT HEADING': { name: 'INTERACTIVE POINT HEADING', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point Jetway constant, determining the desired left bend ratio of jetway hood */ - INTERACTIVE_POINT_JETWAY_LEFT_BEND: { + 'INTERACTIVE POINT JETWAY LEFT BEND': { name: 'INTERACTIVE POINT JETWAY LEFT BEND', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point Jetway constant, determining the desired left deployment angle of jetway hood */ - INTERACTIVE_POINT_JETWAY_LEFT_DEPLOYMENT: { + 'INTERACTIVE POINT JETWAY LEFT DEPLOYMENT': { name: 'INTERACTIVE POINT JETWAY LEFT DEPLOYMENT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point Jetway constant, determining the desired right bend ratio of jetway hood */ - INTERACTIVE_POINT_JETWAY_RIGHT_BEND: { + 'INTERACTIVE POINT JETWAY RIGHT BEND': { name: 'INTERACTIVE POINT JETWAY RIGHT BEND', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point Jetway constant, determining the desired right deployment angle of jetway hood */ - INTERACTIVE_POINT_JETWAY_RIGHT_DEPLOYMENT: { + 'INTERACTIVE POINT JETWAY RIGHT DEPLOYMENT': { name: 'INTERACTIVE POINT JETWAY RIGHT DEPLOYMENT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point Jetway constant, determining the desired top horizontal ratio of displacement of jetway hood */ - INTERACTIVE_POINT_JETWAY_TOP_HORIZONTAL: { + 'INTERACTIVE POINT JETWAY TOP HORIZONTAL': { name: 'INTERACTIVE POINT JETWAY TOP HORIZONTAL', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point Jetway constant, determining the desired top vertical ratio of displacement of jetway hood */ - INTERACTIVE_POINT_JETWAY_TOP_VERTICAL: { + 'INTERACTIVE POINT JETWAY TOP VERTICAL': { name: 'INTERACTIVE POINT JETWAY TOP VERTICAL', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The Interactive Point goal percentage of opening (if it's for a door) or percentage of deployment (if it's for a hose or cable). */ - INTERACTIVE_POINT_GOAL: { + 'INTERACTIVE POINT GOAL': { name: 'INTERACTIVE POINT GOAL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Interactive Point current percentage of opening (if door) or deployment (if hose/cable) */ - INTERACTIVE_POINT_OPEN: { + 'INTERACTIVE POINT OPEN': { name: 'INTERACTIVE POINT OPEN', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Interactive Point orientation: Pitch */ - INTERACTIVE_POINT_PITCH: { + 'INTERACTIVE POINT PITCH': { name: 'INTERACTIVE POINT PITCH', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point X position relative to datum reference point */ - INTERACTIVE_POINT_POSX: { + 'INTERACTIVE POINT POSX': { name: 'INTERACTIVE POINT POSX', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point Y position relative to datum reference point */ - INTERACTIVE_POINT_POSY: { + 'INTERACTIVE POINT POSY': { name: 'INTERACTIVE POINT POSY', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Interactive Point Z position relative to datum reference point */ - INTERACTIVE_POINT_POSZ: { + 'INTERACTIVE POINT POSZ': { name: 'INTERACTIVE POINT POSZ', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The type of interactive point */ - INTERACTIVE_POINT_TYPE: { + 'INTERACTIVE POINT TYPE': { name: 'INTERACTIVE POINT TYPE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Empty weight of the aircraft */ - EMPTY_WEIGHT: { + 'EMPTY WEIGHT': { name: 'EMPTY WEIGHT', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Empty weight cross coupled moment of inertia */ - EMPTY_WEIGHT_CROSS_COUPLED_MOI: { + 'EMPTY WEIGHT CROSS COUPLED MOI': { name: 'EMPTY WEIGHT CROSS COUPLED MOI', units: 'Slugs per feet squared (Slug sqft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Empty weight pitch moment of inertia */ - EMPTY_WEIGHT_PITCH_MOI: { + 'EMPTY WEIGHT PITCH MOI': { name: 'EMPTY WEIGHT PITCH MOI', units: 'Slugs per feet squared (Slug sqft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Empty weight roll moment of inertia */ - EMPTY_WEIGHT_ROLL_MOI: { + 'EMPTY WEIGHT ROLL MOI': { name: 'EMPTY WEIGHT ROLL MOI', units: 'Slugs per feet squared (Slug sqft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Empty weight yaw moment of inertia */ - EMPTY_WEIGHT_YAW_MOI: { + 'EMPTY WEIGHT YAW MOI': { name: 'EMPTY WEIGHT YAW MOI', units: 'Slugs per feet squared (Slug sqft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Maximum gross weight of the aircaft */ - MAX_GROSS_WEIGHT: { + 'MAX GROSS WEIGHT': { name: 'MAX GROSS WEIGHT', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Total weight of the aircraft */ - TOTAL_WEIGHT: { + 'TOTAL WEIGHT': { name: 'TOTAL WEIGHT', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Total weight cross coupled moment of inertia */ - TOTAL_WEIGHT_CROSS_COUPLED_MOI: { + 'TOTAL WEIGHT CROSS COUPLED MOI': { name: 'TOTAL WEIGHT CROSS COUPLED MOI', units: 'Slugs per feet squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Total weight pitch moment of inertia */ - TOTAL_WEIGHT_PITCH_MOI: { + 'TOTAL WEIGHT PITCH MOI': { name: 'TOTAL WEIGHT PITCH MOI', units: 'Slugs per feet squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Total weight roll moment of inertia */ - TOTAL_WEIGHT_ROLL_MOI: { + 'TOTAL WEIGHT ROLL MOI': { name: 'TOTAL WEIGHT ROLL MOI', units: 'Slugs per feet squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Total weight yaw moment of inertia */ - TOTAL_WEIGHT_YAW_MOI: { + 'TOTAL WEIGHT YAW MOI': { name: 'TOTAL WEIGHT YAW MOI', units: 'Slugs per feet squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Cross feed valve setting. This will return the current setting for the fuel crossfeed for the indexed engine, based on the current status of the simulation and the Cross Feed key events. */ - 'FUEL_CROSS_FEED:index': { + /** Cross feed valve setting. This will return the current setting for the fuel crossfeed for the indexed engine, based on the current status of the simulation and the Cross Feed key events. */ + 'FUEL CROSS FEED:index': { name: 'FUEL CROSS FEED:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** If 1 (TRUE) then the aircraft can dump fuel. */ - FUEL_DUMP_ACTIVE: { + 'FUEL DUMP ACTIVE': { name: 'FUEL DUMP ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** If set to 1 (TRUE) then the aircraft will dump fuel at the rate set by fuel_dump_rate parameter in the flight_model.cfg -file. */ - FUEL_DUMP_SWITCH: { + /** If set to 1 (TRUE) then the aircraft will dump fuel at the rate set by fuel_dump_rate parameter in the flight_model.cfg file. */ + 'FUEL DUMP SWITCH': { name: 'FUEL DUMP SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Maximum capacity in volume of all the tanks on the left side of the aircraft. */ - FUEL_LEFT_CAPACITY: { + /** Maximum capacity in volume of all the tanks on the left side of the aircraft. */ + 'FUEL LEFT CAPACITY': { name: 'FUEL LEFT CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Current quantity in volume of all the tanks on the left side of the aircraft. */ - FUEL_LEFT_QUANTITY: { + /** Current quantity in volume of all the tanks on the left side of the aircraft. */ + 'FUEL LEFT QUANTITY': { name: 'FUEL LEFT QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Currently not used within the simulation. */ - FUEL_PUMP: { + /** Currently not used within the simulation. */ + 'FUEL PUMP': { name: 'FUEL PUMP', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Maximum capacity in volume of all the tanks on the right side of the aircraft. */ - FUEL_RIGHT_CAPACITY: { + /** Maximum capacity in volume of all the tanks on the right side of the aircraft. */ + 'FUEL RIGHT CAPACITY': { name: 'FUEL RIGHT CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Current quantity in volume of all the tanks on the right side of the aircraft. */ - FUEL_RIGHT_QUANTITY: { + /** Current quantity in volume of all the tanks on the right side of the aircraft. */ + 'FUEL RIGHT QUANTITY': { name: 'FUEL RIGHT QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Quantity of fuel in the tank referenced by the indexed selector. -When using the legacy fuel system, this SimVar will return the quantity of fuel in the tank pointed to by the selector you chose with the index. If passing an index higher than the number of selectors - or when using the modern fuel system - it will return the total fuel quantity available. */ - 'FUEL_SELECTED_QUANTITY:index': { + /** Quantity of fuel in the tank referenced by the indexed selector. When using the legacy fuel system, this SimVar will return the quantity of fuel in the tank pointed to by the selector you chose with the index. If passing an index higher than the number of selectors - or when using the modern fuel system - it will return the total fuel quantity available. */ + 'FUEL SELECTED QUANTITY:index': { name: 'FUEL SELECTED QUANTITY:index', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Percent or capacity for the tank referenced by the indexed selector. -When using the legacy fuel system, this SimVar will return the percentage of fuel in the tank pointed to by the selector you chose with the index. If passing an index higher than the number of selectors available - or when using the modern fuel system - it will return the percentage of total fuel quantity available. */ - 'FUEL_SELECTED_QUANTITY_PERCENT:index': { + /** Percent or capacity for the tank referenced by the indexed selector. When using the legacy fuel system, this SimVar will return the percentage of fuel in the tank pointed to by the selector you chose with the index. If passing an index higher than the number of selectors available - or when using the modern fuel system - it will return the percentage of total fuel quantity available. */ + 'FUEL SELECTED QUANTITY PERCENT:index': { name: 'FUEL SELECTED QUANTITY PERCENT:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The method of transfer for the fuel. Each of the available transfer options are explained below: - - off - Fuel transfer is switched off. - auto - Automatically balance the fuel between the Center1 and Center2 tanks to maintain the center of gravity. - forward - Fuel will be transferred forwards from the Center1 tank to the Center2 tank. - aft - Fuel will be transferred aftwards from the Center2 tank to the Center1 tank. - manual - Fuel will be transferred for 1 second from the Center1 tank to the Center2 tank at a rate of 1lbs/s. - custom - This requires one or more pumps to have been defined using the fuel_transfer_pump.N parameter in the flight_model.cfg file, as well as their associated electrical circuits. */ - FUEL_SELECTED_TRANSFER_MODE: { + /** +

The method of transfer for the fuel. Each of the available transfer options are explained below:

+
    +
  • off - Fuel transfer is switched off.
    • +
  • auto - Automatically balance the fuel between the Center1 and Center2 tanks to maintain the center of gravity.
    • +
  • forward - Fuel will be transferred forwards from the Center1 tank to the Center2 tank.
    • +
  • aft - Fuel will be transferred aftwards from the Center2 tank to the Center1 tank.
    • +
  • manual - Fuel will be transferred for 1 second from the Center1 tank to the Center2 tank at a rate of 1lbs/s.
    • +
  • custom - This requires one or more pumps to have been defined using the fuel_transfer_pump.N parameter in the flight_model.cfg file, as well as their associated electrical circuits.
    • +
+ */ + 'FUEL SELECTED TRANSFER MODE': { name: 'FUEL SELECTED TRANSFER MODE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Total fuel capacity of the aircraft for all tanks. */ - FUEL_TOTAL_CAPACITY: { + /** Total fuel capacity of the aircraft for all tanks. */ + 'FUEL TOTAL CAPACITY': { name: 'FUEL TOTAL CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Current total quantity of fuel in volume for all tanks of the aircraft. */ - FUEL_TOTAL_QUANTITY: { + /** Current total quantity of fuel in volume for all tanks of the aircraft. */ + 'FUEL TOTAL QUANTITY': { name: 'FUEL TOTAL QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Current total fuel weight for all tanks of the aircraft */ - FUEL_TOTAL_QUANTITY_WEIGHT: { + /** Current total fuel weight for all tanks of the aircraft */ + 'FUEL TOTAL QUANTITY WEIGHT': { name: 'FUEL TOTAL QUANTITY WEIGHT', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns 1 (TRUE) if the indexed pump is active. */ - 'FUEL_TRANSFER_PUMP_ON:index': { + 'FUEL TRANSFER PUMP ON:index': { name: 'FUEL TRANSFER PUMP ON:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The weight of the fuel, per gallon. */ - FUEL_WEIGHT_PER_GALLON: { + 'FUEL WEIGHT PER GALLON': { name: 'FUEL WEIGHT PER GALLON', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Will return 1 (TRUE) if the aircraft is using the modern [FUEL_SYSTEM] or 0 (FALSE) for the legacy [FUEL]. */ - NEW_FUEL_SYSTEM: { + /** Will return 1 (TRUE) if the aircraft is using the modern [FUEL_SYSTEM] or 0 (FALSE) for the legacy [FUEL]. */ + 'NEW FUEL SYSTEM': { name: 'NEW FUEL SYSTEM', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The number of fuel selectors on the aircraft. */ - NUM_FUEL_SELECTORS: { + 'NUM FUEL SELECTORS': { name: 'NUM FUEL SELECTORS', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Will return 1 (TRUE) if the unlimited fuel flag has been enabled, or 0 (FALSE) otherwise. */ - UNLIMITED_FUEL: { + 'UNLIMITED FUEL': { name: 'UNLIMITED FUEL', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The total amount of fuel in all tanks of the aircraft which is not usable. */ - UNUSABLE_FUEL_TOTAL_QUANTITY: { + /** The total amount of fuel in all tanks of the aircraft which is not usable. */ + 'UNUSABLE FUEL TOTAL QUANTITY': { name: 'UNUSABLE FUEL TOTAL QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The pressure of the fuel coming to the indexed engine. The index is the number of the engine N component as defined by the Engine.N parameter. */ - 'FUELSYSTEM_ENGINE_PRESSURE:index': { + /** The pressure of the fuel coming to the indexed engine. The index is the number of the engine N component as defined by the Engine.N parameter. */ + 'FUELSYSTEM ENGINE PRESSURE:index': { name: 'FUELSYSTEM ENGINE PRESSURE:index', units: 'Kilo pascal', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This will return the current Option for the indexed junction. The index is the number of the line N component as defined by the Junction.N parameter. */ - 'FUELSYSTEM_JUNCTION_SETTING:index': { + /** This will return the current Option for the indexed junction. The index is the number of the line N component as defined by the Junction.N parameter. */ + 'FUELSYSTEM JUNCTION SETTING:index': { name: 'FUELSYSTEM JUNCTION SETTING:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The fuel flowing through the indexed line in Gallons per Hour. The index is the number of the line N component as defined by the Line.N parameter. */ - 'FUELSYSTEM_LINE_FUEL_FLOW:index': { + /** The fuel flowing through the indexed line in Gallons per Hour. The index is the number of the line N component as defined by the Line.N parameter. */ + 'FUELSYSTEM LINE FUEL FLOW:index': { name: 'FUELSYSTEM LINE FUEL FLOW:index', units: 'Gallons per hour', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The level of fuel in the indexed line in Gallons. The index is the number of the line N component as defined by the Line.N parameter. */ - 'FUELSYSTEM_LINE_FUEL_LEVEL:index': { + /** The level of fuel in the indexed line in Gallons. The index is the number of the line N component as defined by the Line.N parameter. */ + 'FUELSYSTEM LINE FUEL LEVEL:index': { name: 'FUELSYSTEM LINE FUEL LEVEL:index', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The pressure in the indexed fuel line, measured in KiloPascal. The index is the number of the line N component as defined by the Line.N parameter. */ - 'FUELSYSTEM_LINE_FUEL_PRESSURE:index': { + /** The pressure in the indexed fuel line, measured in KiloPascal. The index is the number of the line N component as defined by the Line.N parameter. */ + 'FUELSYSTEM LINE FUEL PRESSURE:index': { name: 'FUELSYSTEM LINE FUEL PRESSURE:index', units: 'Kilo pascal', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Whether or not the indexed pump is actually active. The index is the number of the pump N component as defined by the Pump.N parameter. */ - 'FUELSYSTEM_PUMP_ACTIVE:index': { + /** Whether or not the indexed pump is actually active. The index is the number of the pump N component as defined by the Pump.N parameter. */ + 'FUELSYSTEM PUMP ACTIVE:index': { name: 'FUELSYSTEM PUMP ACTIVE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Whether or not the indexed pump is enabled. The index is the number of the pump N component as defined by the Pump.N parameter. */ - 'FUELSYSTEM_PUMP_SWITCH:index': { + /** Whether or not the indexed pump is enabled. The index is the number of the pump N component as defined by the Pump.N parameter. */ + 'FUELSYSTEM PUMP SWITCH:index': { name: 'FUELSYSTEM PUMP SWITCH:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Total capacity of the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter. - NOTE: This SimVar can only be used with the modern Fuel System. */ - 'FUELSYSTEM_TANK_CAPACITY:index': { + /** +

Total capacity of the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter.

+

NOTE: This SimVar can only be used with the modern Fuel System.

+ */ + 'FUELSYSTEM TANK CAPACITY:index': { name: 'FUELSYSTEM TANK CAPACITY:index', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Quantity of fuel available in the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter. - NOTE: This SimVar can only be used with the modern Fuel System. */ - 'FUELSYSTEM_TANK_LEVEL:index': { + /** +

Quantity of fuel available in the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter.

+

NOTE: This SimVar can only be used with the modern Fuel System.

+ */ + 'FUELSYSTEM TANK LEVEL:index': { name: 'FUELSYSTEM TANK LEVEL:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Quantity of fuel currently available in the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter. - NOTE: If the fuel system -Version -is 2 or below, the index value will be one of the -Fuel Tank Selection -indices. */ - 'FUELSYSTEM_TANK_QUANTITY:index': { + /** +

Quantity of fuel currently available in the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter.

+

NOTE: If the fuel system Version is 2 or below, the index value will be one of the Fuel Tank Selection indices.

+ */ + 'FUELSYSTEM TANK QUANTITY:index': { name: 'FUELSYSTEM TANK QUANTITY:index', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Total quantity of fuel available in the indexed fuel tank, including any unusable fuel. The index is the number of the tank N component as defined by the Tank.N parameter. - NOTE: If the fuel system -Version -is 2 or below, the index value will be one of the -Fuel Tank Selection -indices. */ - 'FUELSYSTEM_TANK_TOTAL_QUANTITY:index': { + /** +

Total quantity of fuel available in the indexed fuel tank, including any unusable fuel. The index is the number of the tank N component as defined by the Tank.N parameter.

+

NOTE: If the fuel system Version is 2 or below, the index value will be one of the Fuel Tank Selection indices.

+ */ + 'FUELSYSTEM TANK TOTAL QUANTITY:index': { name: 'FUELSYSTEM TANK TOTAL QUANTITY:index', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Weight of fuel available in the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter. - NOTE: If the fuel system -Version -is 2 or below, the index value will be one of the -Fuel Tank Selection -indices. */ - 'FUELSYSTEM_TANK_WEIGHT:index': { + /** +

Weight of fuel available in the indexed fuel tank. The index is the number of the tank N component as defined by the Tank.N parameter.

+

NOTE: If the fuel system Version is 2 or below, the index value will be one of the Fuel Tank Selection indices.

+ */ + 'FUELSYSTEM TANK WEIGHT:index': { name: 'FUELSYSTEM TANK WEIGHT:index', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Whether or not the indexed trigger is active. The index is the number of the trigger N component as defined by the Trigger.N parameter. */ - 'FUELSYSTEM_TRIGGER_STATUS:index': { + /** Whether or not the indexed trigger is active. The index is the number of the trigger N component as defined by the Trigger.N parameter. */ + 'FUELSYSTEM TRIGGER STATUS:index': { name: 'FUELSYSTEM TRIGGER STATUS:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Whether or not the indexed valve is actually fully opened. The index is the number of the valve N component as defined by the Valve.N parameter. */ - 'FUELSYSTEM_VALVE_OPEN:index': { + /** Whether or not the indexed valve is actually fully opened. The index is the number of the valve N component as defined by the Valve.N parameter. */ + 'FUELSYSTEM VALVE OPEN:index': { name: 'FUELSYSTEM VALVE OPEN:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Whether or not the indexed valve is set to be opened. The index is the number of the valve N component as defined by the Valve.N parameter. */ - 'FUELSYSTEM_VALVE_SWITCH:index': { + /** Whether or not the indexed valve is set to be opened. The index is the number of the valve N component as defined by the Valve.N parameter. */ + 'FUELSYSTEM VALVE SWITCH:index': { name: 'FUELSYSTEM VALVE SWITCH:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Maximum capacity in volume of -center tank 1/2/3. */ - FUEL_TANK_CENTER_CAPACITY: { + /** Maximum capacity in volume of center tank 1/2/3. */ + 'FUEL TANK CENTER CAPACITY': { name: 'FUEL TANK CENTER CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Maximum capacity in volume of -center tank 1/2/3. */ - FUEL_TANK_CENTER2_CAPACITY: { + /** Maximum capacity in volume of center tank 1/2/3. */ + 'FUEL TANK CENTER2 CAPACITY': { name: 'FUEL TANK CENTER2 CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Maximum capacity in volume of -center tank 1/2/3. */ - FUEL_TANK_CENTER3_CAPACITY: { + /** Maximum capacity in volume of center tank 1/2/3. */ + 'FUEL TANK CENTER3 CAPACITY': { name: 'FUEL TANK CENTER3 CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent of maximum capacity of center tank 1/2/3. */ - FUEL_TANK_CENTER_LEVEL: { + 'FUEL TANK CENTER LEVEL': { name: 'FUEL TANK CENTER LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Percent of maximum capacity of center tank 1/2/3. */ - FUEL_TANK_CENTER2_LEVEL: { + 'FUEL TANK CENTER2 LEVEL': { name: 'FUEL TANK CENTER2 LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Percent of maximum capacity of center tank 1/2/3. */ - FUEL_TANK_CENTER3_LEVEL: { + 'FUEL TANK CENTER3 LEVEL': { name: 'FUEL TANK CENTER3 LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of center tank 1/2/3. */ - FUEL_TANK_CENTER_QUANTITY: { + 'FUEL TANK CENTER QUANTITY': { name: 'FUEL TANK CENTER QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of center tank 1/2/3. */ - FUEL_TANK_CENTER2_QUANTITY: { + 'FUEL TANK CENTER2 QUANTITY': { name: 'FUEL TANK CENTER2 QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of center tank 1/2/3. */ - FUEL_TANK_CENTER3_QUANTITY: { + 'FUEL TANK CENTER3 QUANTITY': { name: 'FUEL TANK CENTER3 QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Maximum capacity in volume of external tank 1/2. */ - FUEL_TANK_EXTERNAL1_CAPACITY: { + 'FUEL TANK EXTERNAL1 CAPACITY': { name: 'FUEL TANK EXTERNAL1 CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Maximum capacity in volume of external tank 1/2. */ - FUEL_TANK_EXTERNAL2_CAPACITY: { + 'FUEL TANK EXTERNAL2 CAPACITY': { name: 'FUEL TANK EXTERNAL2 CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent of maximum capacity of texternal tank 1/2. */ - FUEL_TANK_EXTERNAL1_LEVEL: { + 'FUEL TANK EXTERNAL1 LEVEL': { name: 'FUEL TANK EXTERNAL1 LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Percent of maximum capacity of texternal tank 1/2. */ - FUEL_TANK_EXTERNAL2_LEVEL: { + 'FUEL TANK EXTERNAL2 LEVEL': { name: 'FUEL TANK EXTERNAL2 LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of external tank 1/2. */ - FUEL_TANK_EXTERNAL1_QUANTITY: { + 'FUEL TANK EXTERNAL1 QUANTITY': { name: 'FUEL TANK EXTERNAL1 QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of external tank 1/2. */ - FUEL_TANK_EXTERNAL2_QUANTITY: { + 'FUEL TANK EXTERNAL2 QUANTITY': { name: 'FUEL TANK EXTERNAL2 QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Maximum capacity in volume of the left auxiliary tank. */ - FUEL_TANK_LEFT_AUX_CAPACITY: { + 'FUEL TANK LEFT AUX CAPACITY': { name: 'FUEL TANK LEFT AUX CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent of maximum capacity of the left auxiliary tank. */ - FUEL_TANK_LEFT_AUX_LEVEL: { + 'FUEL TANK LEFT AUX LEVEL': { name: 'FUEL TANK LEFT AUX LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of the left auxiliary tank. */ - FUEL_TANK_LEFT_AUX_QUANTITY: { + 'FUEL TANK LEFT AUX QUANTITY': { name: 'FUEL TANK LEFT AUX QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Maximum capacity in volume of the left main tank. */ - FUEL_TANK_LEFT_MAIN_CAPACITY: { + 'FUEL TANK LEFT MAIN CAPACITY': { name: 'FUEL TANK LEFT MAIN CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent of maximum capacity of the left main tank. */ - FUEL_TANK_LEFT_MAIN_LEVEL: { + 'FUEL TANK LEFT MAIN LEVEL': { name: 'FUEL TANK LEFT MAIN LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of the left main tank. */ - FUEL_TANK_LEFT_MAIN_QUANTITY: { + 'FUEL TANK LEFT MAIN QUANTITY': { name: 'FUEL TANK LEFT MAIN QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Maximum capacity in volume of the left tip tank. */ - FUEL_TANK_LEFT_TIP_CAPACITY: { + 'FUEL TANK LEFT TIP CAPACITY': { name: 'FUEL TANK LEFT TIP CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent of maximum capacity of the left tip tank. */ - FUEL_TANK_LEFT_TIP_LEVEL: { + 'FUEL TANK LEFT TIP LEVEL': { name: 'FUEL TANK LEFT TIP LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of the left tip tank. */ - FUEL_TANK_LEFT_TIP_QUANTITY: { + 'FUEL TANK LEFT TIP QUANTITY': { name: 'FUEL TANK LEFT TIP QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Maximum capacity in volume of the right auxiliary tank. */ - FUEL_TANK_RIGHT_AUX_CAPACITY: { + 'FUEL TANK RIGHT AUX CAPACITY': { name: 'FUEL TANK RIGHT AUX CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent of maximum capacity of the right auxiliary tank. */ - FUEL_TANK_RIGHT_AUX_LEVEL: { + 'FUEL TANK RIGHT AUX LEVEL': { name: 'FUEL TANK RIGHT AUX LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of the right auxiliary tank. */ - FUEL_TANK_RIGHT_AUX_QUANTITY: { + 'FUEL TANK RIGHT AUX QUANTITY': { name: 'FUEL TANK RIGHT AUX QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Maximum capacity in volume of the right main tank. */ - FUEL_TANK_RIGHT_MAIN_CAPACITY: { + 'FUEL TANK RIGHT MAIN CAPACITY': { name: 'FUEL TANK RIGHT MAIN CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent of maximum capacity of the right main tank. */ - FUEL_TANK_RIGHT_MAIN_LEVEL: { + 'FUEL TANK RIGHT MAIN LEVEL': { name: 'FUEL TANK RIGHT MAIN LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of the right main tank. */ - FUEL_TANK_RIGHT_MAIN_QUANTITY: { + 'FUEL TANK RIGHT MAIN QUANTITY': { name: 'FUEL TANK RIGHT MAIN QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Maximum capacity in volume of the right tip tank. */ - FUEL_TANK_RIGHT_TIP_CAPACITY: { + 'FUEL TANK RIGHT TIP CAPACITY': { name: 'FUEL TANK RIGHT TIP CAPACITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent of maximum capacity of the right tip tank. */ - FUEL_TANK_RIGHT_TIP_LEVEL: { + 'FUEL TANK RIGHT TIP LEVEL': { name: 'FUEL TANK RIGHT TIP LEVEL', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current quantity in volume of the right tip tank. */ - FUEL_TANK_RIGHT_TIP_QUANTITY: { + 'FUEL TANK RIGHT TIP QUANTITY': { name: 'FUEL TANK RIGHT TIP QUANTITY', units: 'Gallons', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Which tank the indexed selector is set to. The index is the selector to check (from 1 to 4), and the return value will be the -Fuel Tank Selection index. - NOTE: This SimVar is only valid for the legacy [FUEL] -setup. */ - 'FUEL_TANK_SELECTOR:index': { + /** +

Which tank the indexed selector is set to. The index is the selector to check (from 1 to 4), and the return value will be the Fuel Tank Selection index.

+

NOTE: This SimVar is only valid for the legacy [FUEL] setup.

+ */ + 'FUEL TANK SELECTOR:index': { name: 'FUEL TANK SELECTOR:index', units: 'Enum', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the aircraft is in a cloud. */ - AMBIENT_IN_CLOUD: { + 'AMBIENT IN CLOUD': { name: 'AMBIENT IN CLOUD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the aircraft has met the conditions required to spawn the contrail VFX. */ - CONTRAILS_CONDITIONS_MET: { + 'CONTRAILS CONDITIONS MET': { name: 'CONTRAILS CONDITIONS MET', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if slew is active. */ - IS_SLEW_ACTIVE: { + 'IS SLEW ACTIVE': { name: 'IS SLEW ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** True if slew is enabled. */ - IS_SLEW_ALLOWED: { + 'IS SLEW ALLOWED': { name: 'IS SLEW ALLOWED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Is this the user loaded aircraft. */ - IS_USER_SIM: { + 'IS USER SIM': { name: 'IS USER SIM', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not the plane is currently on a runway. */ - ON_ANY_RUNWAY: { + 'ON ANY RUNWAY': { name: 'ON ANY RUNWAY', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not the plane is currently parked (true) or not (false). */ - PLANE_IN_PARKING_STATE: { + 'PLANE IN PARKING STATE': { name: 'PLANE IN PARKING STATE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The state of the surface directly under the aircraft. */ - SURFACE_CONDITION: { + 'SURFACE CONDITION': { name: 'SURFACE CONDITION', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** True indicates that the SURFACE CONDITION return value is meaningful. */ - SURFACE_INFO_VALID: { + /** True indicates that the SURFACE CONDITION return value is meaningful. */ + 'SURFACE INFO VALID': { name: 'SURFACE INFO VALID', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The type of surface under the aircraft. */ - SURFACE_TYPE: { + /** +

The type of surface under the aircraft.

+ */ + 'SURFACE TYPE': { name: 'SURFACE TYPE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Amount of ice on aircraft structure. 100 is fully iced. */ - STRUCTURAL_ICE_PCT: { + 'STRUCTURAL ICE PCT': { name: 'STRUCTURAL ICE PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Title from aircraft.cfg. */ + /** Title from aircraft.cfg. */ TITLE: { name: 'TITLE', - units: 'String', + units: '', dataType: SimConnectDataType.STRING8, settable: false, }, /** True if a towline is connected to both tow plane and glider. */ - TOW_CONNECTION: { + 'TOW CONNECTION': { name: 'TOW CONNECTION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is visual effect available on this aircraft. */ - WINDSHIELD_RAIN_EFFECT_AVAILABLE: { + 'WINDSHIELD RAIN EFFECT AVAILABLE': { name: 'WINDSHIELD RAIN EFFECT AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Acceleration relative to aircraft X axis, in east/west direction. */ - ACCELERATION_BODY_X: { + 'ACCELERATION BODY X': { name: 'ACCELERATION BODY X', units: 'Feet (ft) per second squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Acceleration relative to aircraft Y axis, in vertical direction. */ - ACCELERATION_BODY_Y: { + 'ACCELERATION BODY Y': { name: 'ACCELERATION BODY Y', units: 'Feet (ft) per second squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Acceleration relative to aircraft Z axis, in north/south direction. */ - ACCELERATION_BODY_Z: { + 'ACCELERATION BODY Z': { name: 'ACCELERATION BODY Z', units: 'Feet (ft) per second squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Acceleration relative to the earth X axis, in east/west direction. */ - ACCELERATION_WORLD_X: { + 'ACCELERATION WORLD X': { name: 'ACCELERATION WORLD X', units: 'Feet (ft) per second squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Acceleration relative to the earth Y axis, in vertical direction. */ - ACCELERATION_WORLD_Y: { + 'ACCELERATION WORLD Y': { name: 'ACCELERATION WORLD Y', units: 'Feet (ft) per second squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Acceleration relative to the earth Z axis, in north/south direction. */ - ACCELERATION_WORLD_Z: { + 'ACCELERATION WORLD Z': { name: 'ACCELERATION WORLD Z', units: 'Feet (ft) per second squared', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The speed of the aircraft relative to the speed of the first surface directly underneath it. Use this to retrieve, for example, an aircraft's taxiing speed while it is moving on a moving carrier. It also applies to airborne aircraft, for example when a helicopter is successfully hovering above a moving ship, this value should be zero. The returned value will be the same as GROUND VELOCITY if the first surface beneath it is not moving. */ - SURFACE_RELATIVE_GROUND_SPEED: { + /** The speed of the aircraft relative to the speed of the first surface directly underneath it. Use this to retrieve, for example, an aircraft's taxiing speed while it is moving on a moving carrier. It also applies to airborne aircraft, for example when a helicopter is successfully hovering above a moving ship, this value should be zero. The returned value will be the same as GROUND VELOCITY if the first surface beneath it is not moving. */ + 'SURFACE RELATIVE GROUND SPEED': { name: 'SURFACE RELATIVE GROUND SPEED', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Speed relative to the earths surface. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - GROUND_VELOCITY: { + /** +

Speed relative to the earths surface.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'GROUND VELOCITY': { name: 'GROUND VELOCITY', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Altitude of aircraft. */ - PLANE_ALTITUDE: { + 'PLANE ALTITUDE': { name: 'PLANE ALTITUDE', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Altitude above the surface. */ - PLANE_ALT_ABOVE_GROUND: { + 'PLANE ALT ABOVE GROUND': { name: 'PLANE ALT ABOVE GROUND', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Altitude above the surface minus CG. */ - PLANE_ALT_ABOVE_GROUND_MINUS_CG: { + 'PLANE ALT ABOVE GROUND MINUS CG': { name: 'PLANE ALT ABOVE GROUND MINUS CG', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Bank angle, although the name mentions degrees the units used are radians. */ - PLANE_BANK_DEGREES: { + 'PLANE BANK DEGREES': { name: 'PLANE BANK DEGREES', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Heading indicator (directional gyro) indication. */ - PLANE_HEADING_DEGREES_GYRO: { + 'PLANE HEADING DEGREES GYRO': { name: 'PLANE HEADING DEGREES GYRO', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Heading relative to magnetic north - although the name mentions degrees the units used are radians. */ - PLANE_HEADING_DEGREES_MAGNETIC: { + 'PLANE HEADING DEGREES MAGNETIC': { name: 'PLANE HEADING DEGREES MAGNETIC', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Heading relative to true north - although the name mentions degrees the units used are radians. */ - PLANE_HEADING_DEGREES_TRUE: { + 'PLANE HEADING DEGREES TRUE': { name: 'PLANE HEADING DEGREES TRUE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Latitude of aircraft, North is positive, South negative. */ - PLANE_LATITUDE: { + 'PLANE LATITUDE': { name: 'PLANE LATITUDE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Longitude of aircraft, East is positive, West negative. */ - PLANE_LONGITUDE: { + 'PLANE LONGITUDE': { name: 'PLANE LONGITUDE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Pitch angle, although the name mentions degrees the units used are radians. */ - PLANE_PITCH_DEGREES: { + 'PLANE PITCH DEGREES': { name: 'PLANE PITCH DEGREES', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** This float represents the bank of the player's plane from the last touchdown. */ - PLANE_TOUCHDOWN_BANK_DEGREES: { + 'PLANE TOUCHDOWN BANK DEGREES': { name: 'PLANE TOUCHDOWN BANK DEGREES', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the magnetic heading of the player's plane from the last touchdown. */ - PLANE_TOUCHDOWN_HEADING_DEGREES_MAGNETIC: { + 'PLANE TOUCHDOWN HEADING DEGREES MAGNETIC': { name: 'PLANE TOUCHDOWN HEADING DEGREES MAGNETIC', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the true heading of the player's plane from the last touchdown. */ - PLANE_TOUCHDOWN_HEADING_DEGREES_TRUE: { + 'PLANE TOUCHDOWN HEADING DEGREES TRUE': { name: 'PLANE TOUCHDOWN HEADING DEGREES TRUE', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the plane latitude for the last touchdown. */ - PLANE_TOUCHDOWN_LATITUDE: { + 'PLANE TOUCHDOWN LATITUDE': { name: 'PLANE TOUCHDOWN LATITUDE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the plane longitude for the last touchdown. */ - PLANE_TOUCHDOWN_LONGITUDE: { + 'PLANE TOUCHDOWN LONGITUDE': { name: 'PLANE TOUCHDOWN LONGITUDE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the player's plane speed according to ground normal from the last touchdown. */ - PLANE_TOUCHDOWN_NORMAL_VELOCITY: { + 'PLANE TOUCHDOWN NORMAL VELOCITY': { name: 'PLANE TOUCHDOWN NORMAL VELOCITY', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the pitch of the player's plane from the last touchdown. */ - PLANE_TOUCHDOWN_PITCH_DEGREES: { + 'PLANE TOUCHDOWN PITCH DEGREES': { name: 'PLANE TOUCHDOWN PITCH DEGREES', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Lateral (X axis) speed relative to wind. */ - RELATIVE_WIND_VELOCITY_BODY_X: { + 'RELATIVE WIND VELOCITY BODY X': { name: 'RELATIVE WIND VELOCITY BODY X', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Vertical (Y axis) speed relative to wind. */ - RELATIVE_WIND_VELOCITY_BODY_Y: { + 'RELATIVE WIND VELOCITY BODY Y': { name: 'RELATIVE WIND VELOCITY BODY Y', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Longitudinal (Z axis) speed relative to wind. */ - RELATIVE_WIND_VELOCITY_BODY_Z: { + 'RELATIVE WIND VELOCITY BODY Z': { name: 'RELATIVE WIND VELOCITY BODY Z', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Rotation acceleration relative to aircraft X axis. */ - ROTATION_ACCELERATION_BODY_X: { + 'ROTATION ACCELERATION BODY X': { name: 'ROTATION ACCELERATION BODY X', units: 'Radians per second squared', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Rotation acceleration relative to aircraft Y axis. */ - ROTATION_ACCELERATION_BODY_Y: { + 'ROTATION ACCELERATION BODY Y': { name: 'ROTATION ACCELERATION BODY Y', units: 'Radians per second squared', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Rotation acceleration relative to aircraft Z axis. */ - ROTATION_ACCELERATION_BODY_Z: { + 'ROTATION ACCELERATION BODY Z': { name: 'ROTATION ACCELERATION BODY Z', units: 'Radians per second squared', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Rotation velocity relative to aircraft X axis. */ - ROTATION_VELOCITY_BODY_X: { + 'ROTATION VELOCITY BODY X': { name: 'ROTATION VELOCITY BODY X', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Rotation velocity relative to aircraft Y axis. */ - ROTATION_VELOCITY_BODY_Y: { + 'ROTATION VELOCITY BODY Y': { name: 'ROTATION VELOCITY BODY Y', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Rotation velocity relative to aircraft Z axis. */ - ROTATION_VELOCITY_BODY_Z: { + 'ROTATION VELOCITY BODY Z': { name: 'ROTATION VELOCITY BODY Z', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The slope between the plane and the expected landing position of the runway. Returns 0 if no runway is assigned. */ - SLOPE_TO_ATC_RUNWAY: { + 'SLOPE TO ATC RUNWAY': { name: 'SLOPE TO ATC RUNWAY', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True lateral speed, relative to aircraft X axis. */ - VELOCITY_BODY_X: { + 'VELOCITY BODY X': { name: 'VELOCITY BODY X', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** True vertical speed, relative to aircraft Y axis. */ - VELOCITY_BODY_Y: { + 'VELOCITY BODY Y': { name: 'VELOCITY BODY Y', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** True longitudinal speed, relative to aircraft Z axis. */ - VELOCITY_BODY_Z: { + 'VELOCITY BODY Z': { name: 'VELOCITY BODY Z', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The current indicated vertical speed for the aircraft. */ - VERTICAL_SPEED: { + 'VERTICAL SPEED': { name: 'VERTICAL SPEED', units: 'Feet (ft) per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The eyepoint position relative to the reference datum position for the aircraft. */ - EYEPOINT_POSITION: { + 'EYEPOINT POSITION': { name: 'EYEPOINT POSITION', - units: 'SIMCONNECT_DATA_XYZ', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the various airspeed PID constants. This is generally only used for AI controlled aircraft and boats, although it may be useful when working with RTCs and the user aircraft. */ - STRUC_AIRSPEED_HOLD_PID_CONSTS: { + /** Returns the various airspeed PID constants. This is generally only used for AI controlled aircraft and boats, although it may be useful when working with RTCs and the user aircraft. */ + 'STRUC AIRSPEED HOLD PID CONSTS': { name: 'STRUC AIRSPEED HOLD PID CONSTS', - units: 'PID_STRUCT', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the various airspeed PID constants. This is generally only used for AI controlled aircraft and boats, although it may be useful when working with RTCs and the user aircraft. */ - STRUC_HEADING_HOLD_PID_CONSTS: { + /** Returns the various airspeed PID constants. This is generally only used for AI controlled aircraft and boats, although it may be useful when working with RTCs and the user aircraft. */ + 'STRUC HEADING HOLD PID CONSTS': { name: 'STRUC HEADING HOLD PID CONSTS', - units: 'PID_STRUCT', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The body rotation acceleration. */ - STRUCT_BODY_ROTATION_ACCELERATION: { + 'STRUCT BODY ROTATION ACCELERATION': { name: 'STRUCT BODY ROTATION ACCELERATION', - units: 'SIMCONNECT_DATA_XYZ', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The body rotation velocity. */ - STRUCT_BODY_ROTATION_VELOCITY: { + 'STRUCT BODY ROTATION VELOCITY': { name: 'STRUCT BODY ROTATION VELOCITY', - units: 'SIMCONNECT_DATA_XYZ', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The object body velocity. */ - STRUCT_BODY_VELOCITY: { + 'STRUCT BODY VELOCITY': { name: 'STRUCT BODY VELOCITY', - units: 'SIMCONNECT_DATA_XYZ', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The position of the indexed engine relative to the Datum Reference Point for the aircraft. */ - 'STRUCT_ENGINE_POSITION:index': { + /** The position of the indexed engine relative to the Datum Reference Point for the aircraft. */ + 'STRUCT ENGINE POSITION:index': { name: 'STRUCT ENGINE POSITION:index', - units: 'SIMCONNECT_DATA_XYZ', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The angle of the eyepoint view. Zero, zero, zero is straight ahead. */ - STRUCT_EYEPOINT_DYNAMIC_ANGLE: { + 'STRUCT EYEPOINT DYNAMIC ANGLE': { name: 'STRUCT EYEPOINT DYNAMIC ANGLE', - units: 'SIMCONNECT_DATA_XYZ', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** A variable offset away from the EYEPOINT POSITION. */ - STRUCT_EYEPOINT_DYNAMIC_OFFSET: { + 'STRUCT EYEPOINT DYNAMIC OFFSET': { name: 'STRUCT EYEPOINT DYNAMIC OFFSET', - units: 'SIMCONNECT_DATA_XYZ', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns the latitude, longitude and altitude of the user aircraft. */ - STRUCT_LATLONALT: { + 'STRUCT LATLONALT': { name: 'STRUCT LATLONALT', units: 'SIMCONNECT_DATA_LATLONALT', - dataType: SimConnectDataType.LATLONALT, + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns the lattitude, longitude, altitude, pitch, bank and heading of the user aircraft. */ - STRUCT_LATLONALTPBH: { + 'STRUCT LATLONALTPBH': { name: 'STRUCT LATLONALTPBH', - units: 'Returns a struct with 6 values: lat, lon, alt, pitch, bank, heading', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Wind component in aircraft lateral (X) axis. */ - AIRCRAFT_WIND_X: { + 'AIRCRAFT WIND X': { name: 'AIRCRAFT WIND X', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Wind component in aircraft vertical (Y) axis. */ - AIRCRAFT_WIND_Y: { + 'AIRCRAFT WIND Y': { name: 'AIRCRAFT WIND Y', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Wind component in aircraft longitudinal (Z) axis. */ - AIRCRAFT_WIND_Z: { + 'AIRCRAFT WIND Z': { name: 'AIRCRAFT WIND Z', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Redline airspeed (dynamic on some aircraft). */ - AIRSPEED_BARBER_POLE: { + 'AIRSPEED BARBER POLE': { name: 'AIRSPEED BARBER POLE', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Indicated airspeed. */ - AIRSPEED_INDICATED: { + 'AIRSPEED INDICATED': { name: 'AIRSPEED INDICATED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current mach. */ - AIRSPEED_MACH: { + 'AIRSPEED MACH': { name: 'AIRSPEED MACH', units: 'Mach', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The airspeed, whether true or indicated airspeed has been selected. */ - AIRSPEED_SELECT_INDICATED_OR_TRUE: { + 'AIRSPEED SELECT INDICATED OR TRUE': { name: 'AIRSPEED SELECT INDICATED OR TRUE', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True airspeed. */ - AIRSPEED_TRUE: { + 'AIRSPEED TRUE': { name: 'AIRSPEED TRUE', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Equivalent to AIRSPEED TRUE, but does not account for wind when used to Set Airspeed value */ - AIRSPEED_TRUE_RAW: { + /** Equivalent to AIRSPEED TRUE, but does not account for wind when used to Set Airspeed value */ + 'AIRSPEED TRUE RAW': { name: 'AIRSPEED TRUE RAW', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Mach associated with maximum airspeed. */ - BARBER_POLE_MACH: { + 'BARBER POLE MACH': { name: 'BARBER POLE MACH', units: 'Mach', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Velocity regardless of direction. For example, if a helicopter is ascending vertically at 100 fps, getting this variable will return 100. */ - TOTAL_VELOCITY: { + 'TOTAL VELOCITY': { name: 'TOTAL VELOCITY', units: 'Feet (ft per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Longitudinal speed of wind on the windshield. */ - WINDSHIELD_WIND_VELOCITY: { + 'WINDSHIELD WIND VELOCITY': { name: 'WINDSHIELD WIND VELOCITY', units: 'Feet (ft per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Outside temperature on the standard ATM scale. */ - STANDARD_ATM_TEMPERATURE: { + 'STANDARD ATM TEMPERATURE': { name: 'STANDARD ATM TEMPERATURE', units: 'Rankine', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Total air temperature is the air temperature at the front of the aircraft where the ram pressure from the speed of the aircraft is taken into account. */ - TOTAL_AIR_TEMPERATURE: { + 'TOTAL AIR TEMPERATURE': { name: 'TOTAL AIR TEMPERATURE', units: 'Celsius', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** ADF frequency. Index of 1 or 2. */ - 'ADF_ACTIVE_FREQUENCY:index': { + /** The deflection control left / right, usually used for animation.  */ + 'ORNITHOPTER CONTROL LEVERS X': { + name: 'ORNITHOPTER CONTROL LEVERS X', + units: 'Position 16k', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The deflection control fore / aft, usually used for animation. */ + 'ORNITHOPTER CONTROL LEVERS Y': { + name: 'ORNITHOPTER CONTROL LEVERS Y', + units: 'Position 16k', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns whether the ornithopter dive mode is enabled (TRUE) or not (FALSE). */ + 'ORNITHOPTER DIVE MODE ENABLED': { + name: 'ORNITHOPTER DIVE MODE ENABLED', + units: 'Boolean', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the ornithopter glide mode is enabled (TRUE) or not (FALSE). */ + 'ORNITHOPTER GLIDE MODE ENABLED': { + name: 'ORNITHOPTER GLIDE MODE ENABLED', + units: 'Boolean', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the ornithopter wing brake is enabled (TRUE) or not (FALSE). */ + 'ORNITHOPTER WINGS BRAKE ENABLED': { + name: 'ORNITHOPTER WINGS BRAKE ENABLED', + units: 'Boolean', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** Returns whether the ornithopter wing brake is active (TRUE) or not (FALSE). */ + 'ORNITHOPTER WINGS BRAKE ACTIVE': { + name: 'ORNITHOPTER WINGS BRAKE ACTIVE', + units: 'Boolean', + dataType: SimConnectDataType.INT32, + settable: false, + }, + /** The horizontal tilt of the indexed wing expressed as a value between 0 and 1. */ + 'ORNITHOPTER WING HORIZONTAL TILT:index': { + name: 'ORNITHOPTER WING HORIZONTAL TILT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The pitch of the indexed wing expressed as a value between 0 and 1. */ + 'ORNITHOPTER WING PITCH:index': { + name: 'ORNITHOPTER WING PITCH:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The vertical tilt of the indexed wing expressed as a value between 0 and 1. */ + 'ORNITHOPTER WING VERTICAL TILT:index': { + name: 'ORNITHOPTER WING VERTICAL TILT:index', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current amount of blur applied to the animation of the ornithopter wings when flapping, expressed as a value between 0 (none) and 1 (maximum). */ + 'ORNITHOPTER WINGS BLUR': { + name: 'ORNITHOPTER WINGS BLUR', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** The current progress of engaging/disengaging the clutch on the wings when entering or leaving glide mode, expressed as a value between 0 and 1. */ + 'ORNITHOPTER WINGS CLUTCH STATE': { + name: 'ORNITHOPTER WINGS CLUTCH STATE', + units: 'Percent Over 100', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** +

Returns a value that defines the current folding operation of the wings, where:

+
    +
  1. 0 - stand by
    2. +
  2. 1 - parking (slow mode)
    3. +
  3. 2 - setting up (slow mode)
    4. +
  4. 3 - folding for diving (fast mode)
    5. +
  5. 4 - unfolding from a dive (fast mode)
    6. +
+ */ + 'ORNITHOPTER WINGS FOLDING OPERATION ID': { + name: 'ORNITHOPTER WINGS FOLDING OPERATION ID', + units: 'Number', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** Returns the current total lift of the ornithopter. */ + 'ORNITHOPTER WORLD LIFT': { + name: 'ORNITHOPTER WORLD LIFT', + units: 'Pounds (lbs)', + dataType: SimConnectDataType.FLOAT64, + settable: false, + }, + /** ADF frequency. Index of 1 or 2. */ + 'ADF ACTIVE FREQUENCY:index': { name: 'ADF ACTIVE FREQUENCY:index', units: 'Frequency ADF BCD32', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if ADF is available */ - 'ADF_AVAILABLE:index': { + 'ADF AVAILABLE:index': { name: 'ADF AVAILABLE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** ADF compass rose setting */ - ADF_CARD: { + 'ADF CARD': { name: 'ADF CARD', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, use ADF ACTIVE FREQUENCY */ - ADF_EXT_FREQUENCY: { + /** Deprecated, use ADF ACTIVE FREQUENCY */ + 'ADF EXT FREQUENCY': { name: 'ADF EXT FREQUENCY', units: 'Frequency BCD16', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, use ADF ACTIVE FREQUENCY */ - ADF_FREQUENCY: { + /** Deprecated, use ADF ACTIVE FREQUENCY */ + 'ADF FREQUENCY': { name: 'ADF FREQUENCY', units: 'Frequency BCD16', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** ICAO code */ - ADF_IDENT: { + /** ICAO code */ + 'ADF IDENT': { name: 'ADF IDENT', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Returns the latitude, longitude and altitude of the station the radio equipment is currently tuned to, or zeros if the radio is not tuned to any ADF station. Index of 1 or 2 for ADF 1 and ADF 2. */ - 'ADF_LATLONALT:index': { + 'ADF LATLONALT:index': { name: 'ADF LATLONALT:index', - units: 'SIMCONNECT_DATA_LATLONALT', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Descriptive name */ - 'ADF_NAME:index': { + 'ADF NAME:index': { name: 'ADF NAME:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** Current direction from NDB station */ - 'ADF_RADIAL:index': { + /** Current direction from NDB station */ + 'ADF RADIAL:index': { name: 'ADF RADIAL:index', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns the magnetic bearing to the currently tuned ADF transmitter. */ - 'ADF_RADIAL_MAG:index': { + 'ADF RADIAL MAG:index': { name: 'ADF RADIAL MAG:index', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Signal strength */ - 'ADF_SIGNAL:index': { + 'ADF SIGNAL:index': { name: 'ADF SIGNAL:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** ADF audio flag. Index of 0 or 1. */ - 'ADF_SOUND:index': { + /** ADF audio flag. Index of 0 or 1. */ + 'ADF SOUND:index': { name: 'ADF SOUND:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** True if ADF Standby is available */ - 'ADF_STANDBY_AVAILABLE:index': { + /** True if ADF Standby is available */ + 'ADF STANDBY AVAILABLE:index': { name: 'ADF STANDBY AVAILABLE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** ADF standby frequency */ - 'ADF_STANDBY_FREQUENCY:index': { + /** ADF standby frequency */ + 'ADF STANDBY FREQUENCY:index': { name: 'ADF STANDBY FREQUENCY:index', units: 'Hz', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the volume of the ADF */ - ADF_VOLUME: { + /** Returns the volume of the ADF */ + 'ADF VOLUME': { name: 'ADF VOLUME', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The name of the Airline used by ATC, as a string with a maximum length of 50 characters. */ - ATC_AIRLINE: { + 'ATC AIRLINE': { name: 'ATC AIRLINE', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: true, }, /** If the airport is controlled, this boolean is true. */ - ATC_AIRPORT_IS_TOWERED: { + 'ATC AIRPORT IS TOWERED': { name: 'ATC AIRPORT IS TOWERED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns whether or not the user has filed an IFR flightplan that has been cleared by the sim ATC */ - ATC_CLEARED_IFR: { + 'ATC CLEARED IFR': { name: 'ATC CLEARED IFR', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether the ATC has cleared the plane for landing. */ - ATC_CLEARED_LANDING: { + 'ATC CLEARED LANDING': { name: 'ATC CLEARED LANDING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether the ATC has cleared the plane for takeoff. */ - ATC_CLEARED_TAKEOFF: { + 'ATC CLEARED TAKEOFF': { name: 'ATC CLEARED TAKEOFF', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether the ATC has cleared the plane for taxi. */ - ATC_CLEARED_TAXI: { + 'ATC CLEARED TAXI': { name: 'ATC CLEARED TAXI', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns the target altitude for the current ATC flightplan waypoint. */ - ATC_CURRENT_WAYPOINT_ALTITUDE: { + 'ATC CURRENT WAYPOINT ALTITUDE': { name: 'ATC CURRENT WAYPOINT ALTITUDE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Flight Number used by ATC, as a string with a maximum number of 6 characters. */ - ATC_FLIGHT_NUMBER: { + 'ATC FLIGHT NUMBER': { name: 'ATC FLIGHT NUMBER', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: true, }, /** Altitude between the position of the aircraft and his closest waypoints in the flightplan. */ - ATC_FLIGHTPLAN_DIFF_ALT: { + 'ATC FLIGHTPLAN DIFF ALT': { name: 'ATC FLIGHTPLAN DIFF ALT', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the lateral distance the user's plane is from the ATC flight plan track. */ - ATC_FLIGHTPLAN_DIFF_DISTANCE: { + /** Returns the lateral distance the user's plane is from the ATC flight plan track. */ + 'ATC FLIGHTPLAN DIFF DISTANCE': { name: 'ATC FLIGHTPLAN DIFF DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Heading between the position of the aircraft and his closest waypoints in the flightplan. */ - ATC_FLIGHTPLAN_DIFF_HEADING: { + 'ATC FLIGHTPLAN DIFF HEADING': { name: 'ATC FLIGHTPLAN DIFF HEADING', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Is this aircraft recognized by ATC as heavy. */ - ATC_HEAVY: { + 'ATC HEAVY': { name: 'ATC HEAVY', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** ID used by ATC, as a string with a maximum number of 10 characters. */ - ATC_ID: { + 'ATC ID': { name: 'ATC ID', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: true, }, - /** Returns true if the user has a valid IFR flight plan they can as for clearance for with ATC at the airport they are currently at. */ - ATC_IFR_FP_TO_REQUEST: { + /** Returns true if the user has a valid IFR flight plan they can as for clearance for with ATC at the airport they are currently at. */ + 'ATC IFR FP TO REQUEST': { name: 'ATC IFR FP TO REQUEST', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Model used by ATC, as a string with a maximum number of 10 characters. */ - ATC_MODEL: { + 'ATC MODEL': { name: 'ATC MODEL', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Is ATC aircraft on parking spot. */ - ATC_ON_PARKING_SPOT: { + 'ATC ON PARKING SPOT': { name: 'ATC ON PARKING SPOT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns the target altitude for the previous ATC flightplan waypoint. */ - ATC_PREVIOUS_WAYPOINT_ALTITUDE: { + 'ATC PREVIOUS WAYPOINT ALTITUDE': { name: 'ATC PREVIOUS WAYPOINT ALTITUDE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The name of the airport of the runway assigned by the ATC. Returns "" if no runway is assigned. */ - ATC_RUNWAY_AIRPORT_NAME: { + 'ATC RUNWAY AIRPORT NAME': { name: 'ATC RUNWAY AIRPORT NAME', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** This float represents the distance between the player's plane and the center of the runway selected by the ATC. */ - ATC_RUNWAY_DISTANCE: { + 'ATC RUNWAY DISTANCE': { name: 'ATC RUNWAY DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This is a float corresponding to the horizontal distance between the player's plane and the end of the runway selected by the ATC. */ - ATC_RUNWAY_END_DISTANCE: { + 'ATC RUNWAY END DISTANCE': { name: 'ATC RUNWAY END DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the true heading of the runway selected by the ATC. */ - ATC_RUNWAY_HEADING_DEGREES_TRUE: { + 'ATC RUNWAY HEADING DEGREES TRUE': { name: 'ATC RUNWAY HEADING DEGREES TRUE', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The length of the runway assigned by the ATC. Returns -1 if no runway is assigned. */ - ATC_RUNWAY_LENGTH: { + 'ATC RUNWAY LENGTH': { name: 'ATC RUNWAY LENGTH', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This is a float corresponding to the player's main gear relative X (transverse) position on the runway selected by the ATC. */ - ATC_RUNWAY_RELATIVE_POSITION_X: { + 'ATC RUNWAY RELATIVE POSITION X': { name: 'ATC RUNWAY RELATIVE POSITION X', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This is a float corresponding to the player's main gear relative Y (height) position on the runway selected by the ATC. */ - ATC_RUNWAY_RELATIVE_POSITION_Y: { + 'ATC RUNWAY RELATIVE POSITION Y': { name: 'ATC RUNWAY RELATIVE POSITION Y', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This is a float corresponding to the player's main gear relative Z (longitudinal) position on the runway selected by the ATC. */ - ATC_RUNWAY_RELATIVE_POSITION_Z: { + 'ATC RUNWAY RELATIVE POSITION Z': { name: 'ATC RUNWAY RELATIVE POSITION Z', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This is a boolean corresponding to whether or not the ATC has pre-selected a runway for the player's plane. If this is false, every other ATC RUNWAY -* -SimVar will return default values. */ - ATC_RUNWAY_SELECTED: { + /** This is a boolean corresponding to whether or not the ATC has pre-selected a runway for the player's plane. If this is false, every other ATC RUNWAY * SimVar will return default values. */ + 'ATC RUNWAY SELECTED': { name: 'ATC RUNWAY SELECTED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** This is a float corresponding to the horizontal distance between the player's plane and the start of the runway selected by the ATC. */ - ATC_RUNWAY_START_DISTANCE: { + 'ATC RUNWAY START DISTANCE': { name: 'ATC RUNWAY START DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the player's main gear relative X (transverse) position according to the aiming point of the runway selected by the ATC. */ - ATC_RUNWAY_TDPOINT_RELATIVE_POSITION_X: { + 'ATC RUNWAY TDPOINT RELATIVE POSITION X': { name: 'ATC RUNWAY TDPOINT RELATIVE POSITION X', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the player's main gear relative Y (height) position according to the aiming point of the runway selected by the ATC. */ - ATC_RUNWAY_TDPOINT_RELATIVE_POSITION_Y: { + 'ATC RUNWAY TDPOINT RELATIVE POSITION Y': { name: 'ATC RUNWAY TDPOINT RELATIVE POSITION Y', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This float represents the player's main relative Z (longitudinal) position according to the aiming point of the runway selected by the ATC. */ - ATC_RUNWAY_TDPOINT_RELATIVE_POSITION_Z: { + 'ATC RUNWAY TDPOINT RELATIVE POSITION Z': { name: 'ATC RUNWAY TDPOINT RELATIVE POSITION Z', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The width of the runway assigned by the ATC. Returns -1 if no runway is assigned. */ - ATC_RUNWAY_WIDTH: { + 'ATC RUNWAY WIDTH': { name: 'ATC RUNWAY WIDTH', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Suggested minimum runway length for landing. Used by ATC. */ - ATC_SUGGESTED_MIN_RWY_LANDING: { + 'ATC SUGGESTED MIN RWY LANDING': { name: 'ATC SUGGESTED MIN RWY LANDING', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Suggested minimum runway length for takeoff. Used by ATC. */ - ATC_SUGGESTED_MIN_RWY_TAKEOFF: { + 'ATC SUGGESTED MIN RWY TAKEOFF': { name: 'ATC SUGGESTED MIN RWY TAKEOFF', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the lateral distance the user's plane is from the path of the currently issued ATC taxi instructions. */ - ATC_TAXIPATH_DISTANCE: { + /** Returns the lateral distance the user's plane is from the path of the currently issued ATC taxi instructions. */ + 'ATC TAXIPATH DISTANCE': { name: 'ATC TAXIPATH DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Type used by ATC. */ - ATC_TYPE: { + 'ATC TYPE': { name: 'ATC TYPE', units: 'String (30)', dataType: SimConnectDataType.STRINGV, settable: false, }, /** The stored COM 1/2/3 frequency value. */ - COM1_STORED_FREQUENCY: { + 'COM1 STORED FREQUENCY': { name: 'COM1 STORED FREQUENCY', units: 'Frequency BCD16', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The stored COM 1/2/3 frequency value. */ - COM2_STORED_FREQUENCY: { + 'COM2 STORED FREQUENCY': { name: 'COM2 STORED FREQUENCY', units: 'Frequency BCD16', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The stored COM 1/2/3 frequency value. */ - COM3_STORED_FREQUENCY: { + 'COM3 STORED FREQUENCY': { name: 'COM3 STORED FREQUENCY', units: 'Frequency BCD16', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Gives the bearing (in degrees) of the active COM station (airport) or a value less than 0 if the station does not belong to an airport. Index is 1, 2 or 3. */ - 'COM_ACTIVE_BEARING:index': { + /** Gives the bearing (in degrees) of the active COM station (airport) or a value less than 0 if the station does not belong to an airport. Index is 1, 2 or 3. */ + 'COM ACTIVE BEARING:index': { name: 'COM ACTIVE BEARING:index', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Gives the distance (in meters) to the active COM station (airport) or a value less than -180° if the station does not belong to an airport. Index is 1, 2 or 3. */ - 'COM_ACTIVE_DISTANCE:index': { + /** Gives the distance (in meters) to the active COM station (airport) or a value less than -180° if the station does not belong to an airport. Index is 1, 2 or 3. */ + 'COM ACTIVE DISTANCE:index': { name: 'COM ACTIVE DISTANCE:index', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Com frequency. Index is 1, 2 or 3. */ - 'COM_ACTIVE_FREQUENCY:index': { + 'COM ACTIVE FREQUENCY:index': { name: 'COM ACTIVE FREQUENCY:index', units: 'Frequency BCD16', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The identity of the station that is tuned on the indexed active COM radio. Index is 1, 2, or 3. */ - 'COM_ACTIVE_FREQ_IDENT:index': { + 'COM ACTIVE FREQ IDENT:index': { name: 'COM ACTIVE FREQ IDENT:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** The type of COM frequency for the active indexed COM system. Index is 1, 2, or 3. */ - 'COM_ACTIVE_FREQ_TYPE:index': { + 'COM ACTIVE FREQ TYPE:index': { name: 'COM ACTIVE FREQ TYPE:index', - units: 'String:', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** This will return the latitude, longitude and altitude corresponding to the indexed COM station associated with the active COM frequency. If the station is not associated with an airport, then the lat/lon/alt values returned will be -15943°, 80°, -10000 (this means that you can simply check that the altitude value is greater than 0 to assure the validity of the returned struct). - Index is 1, 2 or 3. */ - 'COM_ACTIVE_LATLONALT:index': { + /** +

This will return the latitude, longitude and altitude corresponding to the indexed COM station associated with the active COM frequency. If the station is not associated with an airport, then the lat/lon/alt values returned will be -15943°, 80°, -10000 (this means that you can simply check that the altitude value is greater than 0 to assure the validity of the returned struct).

+

Index is 1, 2 or 3.

+ */ + 'COM ACTIVE LATLONALT:index': { name: 'COM ACTIVE LATLONALT:index', - units: 'Struct:', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if COM1, COM2 or COM3 is available (depending on the index, either 1, 2, or 3) */ - 'COM_AVAILABLE:index': { + 'COM AVAILABLE:index': { name: 'COM AVAILABLE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Not currently used in the simulation. */ - 'COM_LATLONALT:index': { + /** Not currently used in the simulation. */ + 'COM LATLONALT:index': { name: 'COM LATLONALT:index', - units: 'Struct:', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Whether or not the plane is receiving on the indexed com channel or not (either 1, 2, or 3 for the index). */ - 'COM_RECEIVE:index': { + 'COM RECEIVE:index': { name: 'COM RECEIVE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Toggles all COM radios to receive on */ - COM_RECEIVE_ALL: { + 'COM RECEIVE ALL': { name: 'COM RECEIVE ALL', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not the plane is receiving on the indexed com channel. Index is 1, 2 or 3. */ - 'COM_RECEIVE_EX1:index': { + 'COM RECEIVE EX1:index': { name: 'COM RECEIVE EX1:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The COM radio frequency step. Index is 1, 2 or 3. */ - 'COM_SPACING_MODE:index': { + 'COM SPACING MODE:index': { name: 'COM SPACING MODE:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Com standby frequency. Index is 1, 2 or 3. */ - 'COM_STANDBY_FREQUENCY:index': { + 'COM STANDBY FREQUENCY:index': { name: 'COM STANDBY FREQUENCY:index', units: 'Frequency BCD16', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The identity of the station that is tuned on the indexed standby COM radio. Index is 1, 2, or 3. */ - 'COM_STANDBY_FREQ_IDENT:index': { + 'COM STANDBY FREQ IDENT:index': { name: 'COM STANDBY FREQ IDENT:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** The type of COM frequency for the standby indexed COM system. Index is 1, 2, or 3. */ - 'COM_STANDBY_FREQ_TYPE:index': { + 'COM STANDBY FREQ TYPE:index': { name: 'COM STANDBY FREQ TYPE:index', - units: 'String:', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Radio status flag for the indexed com channel. Index is 1, 2 or 3. */ - 'COM_STATUS:index': { + 'COM STATUS:index': { name: 'COM STATUS:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Enter an index of 1, 2 or 3. Will return TRUE if the COM system is working, FALSE otherwise. */ - 'COM_TEST:index': { + /** Enter an index of 1, 2 or 3. Will return TRUE if the COM system is working, FALSE otherwise. */ + 'COM TEST:index': { name: 'COM TEST:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Audio panel com transmit state. Index of 1, 2 or 3. */ - 'COM_TRANSMIT:index': { + 'COM TRANSMIT:index': { name: 'COM TRANSMIT:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The volume of the COM Radio. */ - COM_VOLUME: { + 'COM VOLUME': { name: 'COM VOLUME', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Whether the FLARM is available (TRUE, 1) or not (FALSE, 0). */ - FLARM_AVAILABLE: { + 'FLARM AVAILABLE': { name: 'FLARM AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** The bearing of the FLARM threat aircraft, relative to track. */ - FLARM_THREAT_BEARING: { + 'FLARM THREAT BEARING': { name: 'FLARM THREAT BEARING', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The FLARM threat aircraft data structure, which contains data about the perceived threat, returned as a struct. Struct member variables are as follows: - - id -(U62): the network id of the intruding plane so that they are remembered in order to compute their trajectory. - bearing -(FLOAT64): The threat bearing, in degrees (this is bearing from track axis and not bearing from the airplane axis). - heading -(FLOAT64): The threat heading. - distance -(FLOAT64): -The distance between the aircraft and the threat, in meters. - verticalBearing -(FLOAT64): -The vertical bearing between the aircraft and the threat, in degrees. - relativeAltitude -(FLOAT64): -The relative altitude of the threat to the aircraft, in meters. - timeToCollision -(FLOAT64): -The estimated time to a collision, in seconds. */ - FLARM_THREAT_DATA: { + /** +

The FLARM threat aircraft data structure, which contains data about the perceived threat, returned as a struct. Struct member variables are as follows:

+
    +
  1. id (U62): the network id of the intruding plane so that they are remembered in order to compute their trajectory.
    2. +
  2. bearing (FLOAT64): The threat bearing, in degrees (this is bearing from track axis and not bearing from the airplane axis).
    3. +
  3. heading (FLOAT64): The threat heading.
    4. +
  4. distance (FLOAT64): The distance between the aircraft and the threat, in meters.
    5. +
  5. verticalBearing (FLOAT64): The vertical bearing between the aircraft and the threat, in degrees.
    6. +
  6. relativeAltitude (FLOAT64): The relative altitude of the threat to the aircraft, in meters.
    7. +
  7. timeToCollision (FLOAT64): The estimated time to a collision, in seconds.
    8. +
+ */ + 'FLARM THREAT DATA': { name: 'FLARM THREAT DATA', - units: 'Struct', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The distance to the FLARM threat object. */ - FLARM_THREAT_DISTANCE: { + 'FLARM THREAT DISTANCE': { name: 'FLARM THREAT DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The heading to the FLARM threat object. */ - FLARM_THREAT_HEADING: { + 'FLARM THREAT HEADING': { name: 'FLARM THREAT HEADING', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The relative altitude of the threat object. */ - FLARM_THREAT_RELATIVE_ALTITUDE: { + 'FLARM THREAT RELATIVE ALTITUDE': { name: 'FLARM THREAT RELATIVE ALTITUDE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The estimated time to a collision. */ - FLARM_THREAT_TIME_TO_COLLISION: { + 'FLARM THREAT TIME TO COLLISION': { name: 'FLARM THREAT TIME TO COLLISION', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The vertical bearing towards the threat. */ - FLARM_THREAT_VERTICAL_BEARING: { + 'FLARM THREAT VERTICAL BEARING': { name: 'FLARM THREAT VERTICAL BEARING', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** ID of airport. */ - GPS_APPROACH_AIRPORT_ID: { + 'GPS APPROACH AIRPORT ID': { name: 'GPS APPROACH AIRPORT ID', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** ID of approach. */ - GPS_APPROACH_APPROACH_ID: { + 'GPS APPROACH APPROACH ID': { name: 'GPS APPROACH APPROACH ID', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Index of approach for given airport. */ - GPS_APPROACH_APPROACH_INDEX: { + 'GPS APPROACH APPROACH INDEX': { name: 'GPS APPROACH APPROACH INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Approach type. */ - GPS_APPROACH_APPROACH_TYPE: { + 'GPS APPROACH APPROACH TYPE': { name: 'GPS APPROACH APPROACH TYPE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Is approach transition final approach segment. */ - GPS_APPROACH_IS_FINAL: { + 'GPS APPROACH IS FINAL': { name: 'GPS APPROACH IS FINAL', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Is approach segment missed approach segment. */ - GPS_APPROACH_IS_MISSED: { + 'GPS APPROACH IS MISSED': { name: 'GPS APPROACH IS MISSED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Waypoint is the runway. */ - GPS_APPROACH_IS_WP_RUNWAY: { + 'GPS APPROACH IS WP RUNWAY': { name: 'GPS APPROACH IS WP RUNWAY', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Sub mode within approach mode. */ - GPS_APPROACH_MODE: { + 'GPS APPROACH MODE': { name: 'GPS APPROACH MODE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Segment type within approach. */ - GPS_APPROACH_SEGMENT_TYPE: { + 'GPS APPROACH SEGMENT TYPE': { name: 'GPS APPROACH SEGMENT TYPE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Deviation of local time from GMT. */ - GPS_APPROACH_TIMEZONE_DEVIATION: { + 'GPS APPROACH TIMEZONE DEVIATION': { name: 'GPS APPROACH TIMEZONE DEVIATION', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** ID of approach transition. */ - GPS_APPROACH_TRANSITION_ID: { + 'GPS APPROACH TRANSITION ID': { name: 'GPS APPROACH TRANSITION ID', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Index of approach transition. */ - GPS_APPROACH_TRANSITION_INDEX: { + 'GPS APPROACH TRANSITION INDEX': { name: 'GPS APPROACH TRANSITION INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Number of waypoints. */ - GPS_APPROACH_WP_COUNT: { + 'GPS APPROACH WP COUNT': { name: 'GPS APPROACH WP COUNT', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Index of current waypoint. */ - GPS_APPROACH_WP_INDEX: { + 'GPS APPROACH WP INDEX': { name: 'GPS APPROACH WP INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Waypoint type within approach mode. */ - GPS_APPROACH_WP_TYPE: { + 'GPS APPROACH WP TYPE': { name: 'GPS APPROACH WP TYPE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** The course deviation of the needle for a CDI instrument. The SimVar displays the deviation from -127 to +127. It returns a value if a flight plan is set (otherwise it will return 0) even if the autopilot isn't on GPS mode. Scaling can also be set through the GPS CDI SCALING simvar. */ - GPS_CDI_NEEDLE: { + /** The course deviation of the needle for a CDI instrument. The SimVar displays the deviation from -127 to +127. It returns a value if a flight plan is set (otherwise it will return 0) even if the autopilot isn't on GPS mode. Scaling can also be set through the GPS CDI SCALING simvar. */ + 'GPS CDI NEEDLE': { name: 'GPS CDI NEEDLE', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The full scale deflection of the CDI due to GPS cross-track error, in meters. */ - GPS_CDI_SCALING: { + 'GPS CDI SCALING': { name: 'GPS CDI SCALING', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Suggested heading to steer (for autopilot). */ - GPS_COURSE_TO_STEER: { + 'GPS COURSE TO STEER': { name: 'GPS COURSE TO STEER', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** GPS is driving Nav 1 indicator. Note this setting will also affect the SimVars HSI_STATION_IDENT and HSI_BEARING. */ - GPS_DRIVES_NAV1: { + /** GPS is driving Nav 1 indicator. Note this setting will also affect the SimVars HSI_STATION_IDENT and HSI_BEARING. */ + 'GPS DRIVES NAV1': { name: 'GPS DRIVES NAV1', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Estimated time of arrival at destination. */ - GPS_ETA: { + 'GPS ETA': { name: 'GPS ETA', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Estimated time en route to destination. */ - GPS_ETE: { + 'GPS ETE': { name: 'GPS ETE', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This is the complete flightplan length from start to end. Essentially the cumulative length of all the flight plan legs added together. */ - GPS_FLIGHTPLAN_TOTAL_DISTANCE: { + 'GPS FLIGHTPLAN TOTAL DISTANCE': { name: 'GPS FLIGHTPLAN TOTAL DISTANCE', - units: 'Meters', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Number of waypoints. */ - GPS_FLIGHT_PLAN_WP_COUNT: { + 'GPS FLIGHT PLAN WP COUNT': { name: 'GPS FLIGHT PLAN WP COUNT', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Index of waypoint. */ - GPS_FLIGHT_PLAN_WP_INDEX: { + 'GPS FLIGHT PLAN WP INDEX': { name: 'GPS FLIGHT PLAN WP INDEX', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current magnetic ground track. */ - GPS_GROUND_MAGNETIC_TRACK: { + 'GPS GROUND MAGNETIC TRACK': { name: 'GPS GROUND MAGNETIC TRACK', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current ground speed. */ - GPS_GROUND_SPEED: { + 'GPS GROUND SPEED': { name: 'GPS GROUND SPEED', units: 'Meters per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current true heading. */ - GPS_GROUND_TRUE_HEADING: { + 'GPS GROUND TRUE HEADING': { name: 'GPS GROUND TRUE HEADING', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current true ground track. */ - GPS_GROUND_TRUE_TRACK: { + 'GPS GROUND TRUE TRACK': { name: 'GPS GROUND TRUE TRACK', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The full scale deflection of the vertical GSI due to GPS glidepath deviation, in meters. */ - GPS_GSI_SCALING: { + 'GPS GSI SCALING': { name: 'GPS GSI SCALING', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Whether or not the GPS system has a presently available glidepath for guidance. Only applicable with GPS_OVERRIDDEN. When true and in GPS OVERRIDDEN, HSI_GSI_NEEDLE_VALID will also be true. */ - GPS_HAS_GLIDEPATH: { + /** Whether or not the GPS system has a presently available glidepath for guidance. Only applicable with GPS_OVERRIDDEN. When true and in GPS OVERRIDDEN, HSI_GSI_NEEDLE_VALID will also be true. */ + 'GPS HAS GLIDEPATH': { name: 'GPS HAS GLIDEPATH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** The glide deviation of the needle for a CDI instrument. The simvar displays the deviation from -127 to +127. It returns a value if a flight plan is set (otherwise it will return 0) even if the autopilot isn't on GPS mode. Scaling can also be set through the GPS CDI SCALING simvar. */ - GPS_HSI_NEEDLE: { + /** The glide deviation of the needle for a CDI instrument. The simvar displays the deviation from -127 to +127. It returns a value if a flight plan is set (otherwise it will return 0) even if the autopilot isn't on GPS mode. Scaling can also be set through the GPS CDI SCALING simvar. */ + 'GPS HSI NEEDLE': { name: 'GPS HSI NEEDLE', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Flight plan mode active. */ - GPS_IS_ACTIVE_FLIGHT_PLAN: { + 'GPS IS ACTIVE FLIGHT PLAN': { name: 'GPS IS ACTIVE FLIGHT PLAN', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Waypoint mode active. */ - GPS_IS_ACTIVE_WAY_POINT: { + 'GPS IS ACTIVE WAY POINT': { name: 'GPS IS ACTIVE WAY POINT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Is switching to next waypoint locked. */ - GPS_IS_ACTIVE_WP_LOCKED: { + 'GPS IS ACTIVE WP LOCKED': { name: 'GPS IS ACTIVE WP LOCKED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is approach mode active. */ - GPS_IS_APPROACH_ACTIVE: { + 'GPS IS APPROACH ACTIVE': { name: 'GPS IS APPROACH ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is approach loaded. */ - GPS_IS_APPROACH_LOADED: { + 'GPS IS APPROACH LOADED': { name: 'GPS IS APPROACH LOADED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is flight plan destination reached. */ - GPS_IS_ARRIVED: { + 'GPS IS ARRIVED': { name: 'GPS IS ARRIVED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Is Direct To Waypoint mode active. */ - GPS_IS_DIRECTTO_FLIGHTPLAN: { + 'GPS IS DIRECTTO FLIGHTPLAN': { name: 'GPS IS DIRECTTO FLIGHTPLAN', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Current GPS magnetic variation. */ - GPS_MAGVAR: { + 'GPS MAGVAR': { name: 'GPS MAGVAR', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Whether or not the OBS mode is currently active (disable the automatic sequencing of waypoints in GPS flight plan). */ - GPS_OBS_ACTIVE: { + 'GPS OBS ACTIVE': { name: 'GPS OBS ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** This is the currently selected OBS course in degrees, from 0 to 360. */ - GPS_OBS_VALUE: { + 'GPS OBS VALUE': { name: 'GPS OBS VALUE', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** When it is active, all sim GPS system updates are suspended. This must be set to TRUE to be able to correctly set to any other GPS SimVar. */ - GPS_OVERRIDDEN: { + 'GPS OVERRIDDEN': { name: 'GPS OVERRIDDEN', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Current GPS altitude. */ - GPS_POSITION_ALT: { + 'GPS POSITION ALT': { name: 'GPS POSITION ALT', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current GPS latitude. */ - GPS_POSITION_LAT: { + 'GPS POSITION LAT': { name: 'GPS POSITION LAT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current GPS longitude. */ - GPS_POSITION_LON: { + 'GPS POSITION LON': { name: 'GPS POSITION LON', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Altitude of GPS target. */ - GPS_TARGET_ALTITUDE: { + 'GPS TARGET ALTITUDE': { name: 'GPS TARGET ALTITUDE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Distance to target. */ - GPS_TARGET_DISTANCE: { + 'GPS TARGET DISTANCE': { name: 'GPS TARGET DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Glidepath in degrees. */ - GPS_VERTICAL_ANGLE: { + 'GPS VERTICAL ANGLE': { name: 'GPS VERTICAL ANGLE', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Vertical error in degrees from GlidePath. */ - GPS_VERTICAL_ANGLE_ERROR: { + 'GPS VERTICAL ANGLE ERROR': { name: 'GPS VERTICAL ANGLE ERROR', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Vertical deviation in meters from GlidePath. */ - GPS_VERTICAL_ERROR: { + 'GPS VERTICAL ERROR': { name: 'GPS VERTICAL ERROR', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Magnetic bearing to waypoint. */ - GPS_WP_BEARING: { + 'GPS WP BEARING': { name: 'GPS WP BEARING', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Cross track distance. */ - GPS_WP_CROSS_TRK: { + 'GPS WP CROSS TRK': { name: 'GPS WP CROSS TRK', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The required heading (magnetic) from the previous waypoint to the next waypoint. */ - GPS_WP_DESIRED_TRACK: { + 'GPS WP DESIRED TRACK': { name: 'GPS WP DESIRED TRACK', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Distance to waypoint. */ - GPS_WP_DISTANCE: { + 'GPS WP DISTANCE': { name: 'GPS WP DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Estimated time of arrival at waypoint. */ - GPS_WP_ETA: { + 'GPS WP ETA': { name: 'GPS WP ETA', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Estimated time en route to waypoint. */ - GPS_WP_ETE: { + 'GPS WP ETE': { name: 'GPS WP ETE', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Altitude of next waypoint. */ - GPS_WP_NEXT_ALT: { + 'GPS WP NEXT ALT': { name: 'GPS WP NEXT ALT', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** ID of next GPS waypoint. */ - GPS_WP_NEXT_ID: { + 'GPS WP NEXT ID': { name: 'GPS WP NEXT ID', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: true, }, /** Latitude of next waypoint. */ - GPS_WP_NEXT_LAT: { + 'GPS WP NEXT LAT': { name: 'GPS WP NEXT LAT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Longitude of next waypoint. */ - GPS_WP_NEXT_LON: { + 'GPS WP NEXT LON': { name: 'GPS WP NEXT LON', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Altitude of previous waypoint. */ - GPS_WP_PREV_ALT: { + 'GPS WP PREV ALT': { name: 'GPS WP PREV ALT', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** ID of previous GPS waypoint. */ - GPS_WP_PREV_ID: { + 'GPS WP PREV ID': { name: 'GPS WP PREV ID', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: true, }, /** Latitude of previous waypoint. */ - GPS_WP_PREV_LAT: { + 'GPS WP PREV LAT': { name: 'GPS WP PREV LAT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Longitude of previous waypoint. */ - GPS_WP_PREV_LON: { + 'GPS WP PREV LON': { name: 'GPS WP PREV LON', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Is previous waypoint valid (i.e. current waypoint is not the first waypoint). */ - GPS_WP_PREV_VALID: { + 'GPS WP PREV VALID': { name: 'GPS WP PREV VALID', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Tracking angle error to waypoint. */ - GPS_WP_TRACK_ANGLE_ERROR: { + 'GPS WP TRACK ANGLE ERROR': { name: 'GPS WP TRACK ANGLE ERROR', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** True bearing to waypoint. */ - GPS_WP_TRUE_BEARING: { + 'GPS WP TRUE BEARING': { name: 'GPS WP TRUE BEARING', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Required true heading to waypoint. */ - GPS_WP_TRUE_REQ_HDG: { + 'GPS WP TRUE REQ HDG': { name: 'GPS WP TRUE REQ HDG', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Vertical speed to waypoint. */ - GPS_WP_VERTICAL_SPEED: { + 'GPS WP VERTICAL SPEED': { name: 'GPS WP VERTICAL SPEED', units: 'Meters per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** If the GPS_DRIVES_NAV1 variable is true and the HSI BEARING VALID variable is true, this variable contains the HSI needle bearing. If the GPS DRIVES NAV1 variable is false and the HSI BEARING VALID variable is true, this variable contains the ADF1 frequency. */ - HSI_BEARING: { + /** If the GPS_DRIVES_NAV1 variable is true and the HSI BEARING VALID variable is true, this variable contains the HSI needle bearing. If the GPS DRIVES NAV1 variable is false and the HSI BEARING VALID variable is true, this variable contains the ADF1 frequency. */ + 'HSI BEARING': { name: 'HSI BEARING', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This will return true if the HSI BEARING variable contains valid data. */ - HSI_BEARING_VALID: { + /** This will return true if the HSI BEARING variable contains valid data. */ + 'HSI BEARING VALID': { name: 'HSI BEARING VALID', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Needle deflection (+/- 127). */ - HSI_CDI_NEEDLE: { + 'HSI CDI NEEDLE': { name: 'HSI CDI NEEDLE', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Signal valid. */ - HSI_CDI_NEEDLE_VALID: { + 'HSI CDI NEEDLE VALID': { name: 'HSI CDI NEEDLE VALID', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** DME/GPS distance. */ - HSI_DISTANCE: { + 'HSI DISTANCE': { name: 'HSI DISTANCE', units: 'Nautical miles', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Needle deflection (+/- 119). */ - HSI_GSI_NEEDLE: { + 'HSI GSI NEEDLE': { name: 'HSI GSI NEEDLE', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Signal valid. */ - HSI_GSI_NEEDLE_VALID: { + 'HSI GSI NEEDLE VALID': { name: 'HSI GSI NEEDLE VALID', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Station is a localizer. */ - HSI_HAS_LOCALIZER: { + 'HSI HAS LOCALIZER': { name: 'HSI HAS LOCALIZER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** DME/GPS speed. */ - HSI_SPEED: { + 'HSI SPEED': { name: 'HSI SPEED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the ident of the the next GPS waypoint, if GPS_DRIVES_NAV1 is true. If GPS DRIVES NAV1 is false, it returns the identity of the station that is tuned on nav radio 1. */ - HSI_STATION_IDENT: { + /** Returns the ident of the the next GPS waypoint, if GPS_DRIVES_NAV1 is true. If GPS DRIVES NAV1 is false, it returns the identity of the station that is tuned on nav radio 1. */ + 'HSI STATION IDENT': { name: 'HSI STATION IDENT', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Nav TO/FROM flag. */ - HSI_TF_FLAGS: { + 'HSI TF FLAGS': { name: 'HSI TF FLAGS', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Inner marker state. */ - INNER_MARKER: { + 'INNER MARKER': { name: 'INNER MARKER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Returns the latitude, longitude and altitude of the inner marker of an approach to a runway, if the aircraft is within the required proximity, otherwise it will return zeros. */ - INNER_MARKER_LATLONALT: { + 'INNER MARKER LATLONALT': { name: 'INNER MARKER LATLONALT', - units: 'SIMCONNECT_DATA_LATLONALT', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if Marker is available. */ - MARKER_AVAILABLE: { + 'MARKER AVAILABLE': { name: 'MARKER AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not the Marker Beacon is in High Sensitivity mode. */ - MARKER_BEACON_SENSITIVITY_HIGH: { + 'MARKER BEACON SENSITIVITY HIGH': { name: 'MARKER BEACON SENSITIVITY HIGH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Marker beacon state. */ - MARKER_BEACON_STATE: { + 'MARKER BEACON STATE': { name: 'MARKER BEACON STATE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Whether or not the Marker Beacon is in Test/Mute mode. */ - MARKER_BEACON_TEST_MUTE: { + 'MARKER BEACON TEST MUTE': { name: 'MARKER BEACON TEST MUTE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Marker audio flag. */ - MARKER_SOUND: { + 'MARKER SOUND': { name: 'MARKER SOUND', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Middle marker state. */ - MIDDLE_MARKER: { + 'MIDDLE MARKER': { name: 'MIDDLE MARKER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Returns the latitude, longitude and altitude of the middle marker. */ - MIDDLE_MARKER_LATLONALT: { + 'MIDDLE MARKER LATLONALT': { name: 'MIDDLE MARKER LATLONALT', - units: 'SIMCONNECT_DATA_LATLONALT', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Outer marker state. */ - OUTER_MARKER: { + 'OUTER MARKER': { name: 'OUTER MARKER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Returns the latitude, longitude and altitude of the outer marker. */ - OUTER_MARKER_LATLONALT: { + 'OUTER MARKER LATLONALT': { name: 'OUTER MARKER LATLONALT', - units: 'SIMCONNECT_DATA_LATLONALT', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Nav active frequency. Index is 1 or 2. */ - 'NAV_ACTIVE_FREQUENCY:index': { + 'NAV ACTIVE FREQUENCY:index': { name: 'NAV ACTIVE FREQUENCY:index', units: 'MHz', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Flag if Nav equipped on aircraft. */ - 'NAV_AVAILABLE:index': { + 'NAV AVAILABLE:index': { name: 'NAV AVAILABLE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns the listed bit flags. */ - 'NAV_BACK_COURSE_FLAGS:index': { + 'NAV BACK COURSE FLAGS:index': { name: 'NAV BACK COURSE FLAGS:index', - units: 'Flags:', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** CDI needle deflection (+/- 127). */ - 'NAV_CDI:index': { + 'NAV CDI:index': { name: 'NAV CDI:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Closest DME distance. Requires an index value from 1 to 4 to set which NAV to target. - Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ - 'NAV_CLOSE_DME:index': { + /** +

Closest DME distance. Requires an index value from 1 to 4 to set which NAV to target.

+

Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE).

+ */ + 'NAV CLOSE DME:index': { name: 'NAV CLOSE DME:index', units: 'Nautical miles', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Closest Localizer course frequency. Requires an index value from 1 to 4 to set which NAV to target. - Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ - 'NAV_CLOSE_FREQUENCY:index': { +

Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE).

+ */ + 'NAV CLOSE FREQUENCY:index': { name: 'NAV CLOSE FREQUENCY:index', units: 'Hz', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** ICAO code. Requires an index value from 1 to 4 to set which NAV to target. - Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ - 'NAV_CLOSE_IDENT:index': { +

Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE).

+ */ + 'NAV CLOSE IDENT:index': { name: 'NAV CLOSE IDENT:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Closest Localizer course heading. Requires an index value from 1 to 4 to set which NAV to target. - Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ - 'NAV_CLOSE_LOCALIZER:index': { +

Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE).

+ */ + 'NAV CLOSE LOCALIZER:index': { name: 'NAV CLOSE LOCALIZER:index', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Descriptive name. Requires an index value from 1 to 4 to set which NAV to target. - Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE). */ - 'NAV_CLOSE_NAME:index': { +

Note that this SimVar will only work if the NAV1_CLOSE_FREQ_SET key event has been set to 1 (TRUE).

+ */ + 'NAV CLOSE NAME:index': { name: 'NAV CLOSE NAME:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Returns bit flags with the listed meaning. */ - NAV_CODES: { + 'NAV CODES': { name: 'NAV CODES', - units: 'Flags:', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** DME distance. */ - NAV_DME: { + 'NAV DME': { name: 'NAV DME', units: 'Nautical miles', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** DME speed. */ - NAV_DMESPEED: { + 'NAV DMESPEED': { name: 'NAV DMESPEED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns the DME station. */ - 'NAV_DME_LATLONALT:index': { + 'NAV DME LATLONALT:index': { name: 'NAV DME LATLONALT:index', - units: 'SIMCONNECT_DATA_LATLONALT structure', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Localizer course frequency */ - NAV_FREQUENCY: { + 'NAV FREQUENCY': { name: 'NAV FREQUENCY', units: 'Hz', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The glide slope gradient. The value returned is an integer value formed as follows: - sin(slope) * 65536 * 2 - So, for example, a glide slope of 2.7º would return a value of 6174. TO get the value in degrees, then use -NAV_RAW_GLIDE_SLOPE instead. */ - NAV_GLIDE_SLOPE: { + /** +

The glide slope gradient. The value returned is an integer value formed as follows:

+ 
sin(slope) * 65536 * 2
+

So, for example, a glide slope of 2.7º would return a value of 6174. TO get the value in degrees, then use NAV_RAW_GLIDE_SLOPE instead.

+ */ + 'NAV GLIDE SLOPE': { name: 'NAV GLIDE SLOPE', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Difference between current position and glideslope angle. Note that this provides 32 bit floating point precision, rather than the 8 bit integer precision of NAV GSI. */ - NAV_GLIDE_SLOPE_ERROR: { + 'NAV GLIDE SLOPE ERROR': { name: 'NAV GLIDE SLOPE ERROR', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The distance between the plane and the Glide beacon. */ - NAV_GLIDE_SLOPE_LENGTH: { + 'NAV GLIDE SLOPE LENGTH': { name: 'NAV GLIDE SLOPE LENGTH', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Glideslope needle deflection (+/- 119). Note that this provides only 8 bit precision, whereas NAV GLIDE SLOPE ERROR provides 32 bit floating point precision. */ - NAV_GSI: { + 'NAV GSI': { name: 'NAV GSI', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Glideslope flag. */ - NAV_GS_FLAG: { + 'NAV GS FLAG': { name: 'NAV GS FLAG', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Returns the glide slope. */ - 'NAV_GS_LATLONALT:index': { + 'NAV GS LATLONALT:index': { name: 'NAV GS LATLONALT:index', - units: 'SIMCONNECT_DATA_LATLONALT structure', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Nav GS latitude, longitude, altitude. */ - NAV_GS_LLAF64: { + 'NAV GS LLAF64': { name: 'NAV GS LLAF64', - units: 'SIMCONNECT_DATA_LATLONALT structure', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Flag if found a close station with a DME. */ - NAV_HAS_CLOSE_DME: { + 'NAV HAS CLOSE DME': { name: 'NAV HAS CLOSE DME', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Flag if found a close localizer station. */ - NAV_HAS_CLOSE_LOCALIZER: { + 'NAV HAS CLOSE LOCALIZER': { name: 'NAV HAS CLOSE LOCALIZER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Flag if tuned station has a DME. */ - NAV_HAS_DME: { + 'NAV HAS DME': { name: 'NAV HAS DME', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Flag if tuned station has a glideslope. */ - NAV_HAS_GLIDE_SLOPE: { + 'NAV HAS GLIDE SLOPE': { name: 'NAV HAS GLIDE SLOPE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Flag if tuned station is a localizer. */ - NAV_HAS_LOCALIZER: { + 'NAV HAS LOCALIZER': { name: 'NAV HAS LOCALIZER', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Flag if Nav has signal. */ - NAV_HAS_NAV: { + 'NAV HAS NAV': { name: 'NAV HAS NAV', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Flag if Nav has a Tacan. */ - NAV_HAS_TACAN: { + /** Flag if Nav has a Tacan. */ + 'NAV HAS TACAN': { name: 'NAV HAS TACAN', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** ICAO code. */ - NAV_IDENT: { + 'NAV IDENT': { name: 'NAV IDENT', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Localizer course heading. */ - NAV_LOCALIZER: { + 'NAV LOCALIZER': { name: 'NAV LOCALIZER', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The airport ICAO ident for the localizer that is currently tuned on the nav radio (like 'EGLL' or 'KJFK') */ - NAV_LOC_AIRPORT_IDENT: { + 'NAV LOC AIRPORT IDENT': { name: 'NAV LOC AIRPORT IDENT', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** The letter code for the runway that the currently tuned localizer is tuned to. */ - NAV_LOC_RUNWAY_DESIGNATOR: { + 'NAV LOC RUNWAY DESIGNATOR': { name: 'NAV LOC RUNWAY DESIGNATOR', units: 'String', dataType: SimConnectDataType.STRINGV, settable: false, }, /** NAV LOC RUNWAY NUMBER - The number portion of the runway that the currently tuned localizer is tuned to (so if the runway was 15L, this would be 15). */ - NAV_LOC_RUNWAY_NUMBER: { + 'NAV LOC RUNWAY NUMBER': { name: 'NAV LOC RUNWAY NUMBER', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Magnetic variation of tuned Nav station. */ - NAV_MAGVAR: { + 'NAV MAGVAR': { name: 'NAV MAGVAR', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Descriptive name. */ - NAV_NAME: { + 'NAV NAME': { name: 'NAV NAME', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** OBS setting. Index of 1 or 2. */ - NAV_OBS: { + 'NAV OBS': { name: 'NAV OBS', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Radial that aircraft is on. */ - NAV_RADIAL: { + 'NAV RADIAL': { name: 'NAV RADIAL', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Difference between current radial and OBS tuned radial. */ - NAV_RADIAL_ERROR: { + 'NAV RADIAL ERROR': { name: 'NAV RADIAL ERROR', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The glide slope angle. */ - NAV_RAW_GLIDE_SLOPE: { + 'NAV RAW GLIDE SLOPE': { name: 'NAV RAW GLIDE SLOPE', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Relative bearing to station. */ - NAV_RELATIVE_BEARING_TO_STATION: { + 'NAV RELATIVE BEARING TO STATION': { name: 'NAV RELATIVE BEARING TO STATION', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Nav signal strength. */ - NAV_SIGNAL: { + 'NAV SIGNAL': { name: 'NAV SIGNAL', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Nav audio flag. Index of 1 or 2. */ - 'NAV_SOUND:index': { + 'NAV SOUND:index': { name: 'NAV SOUND:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Nav standby frequency. Index is 1 or 2. */ - 'NAV_STANDBY_FREQUENCY:index': { + 'NAV STANDBY FREQUENCY:index': { name: 'NAV STANDBY FREQUENCY:index', units: 'MHz', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns whether the Nav is going to or from the current radial (or is off). */ - NAV_TOFROM: { + 'NAV TOFROM': { name: 'NAV TOFROM', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** The volume of the Nav radio. */ - NAV_VOLUME: { + 'NAV VOLUME': { name: 'NAV VOLUME', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Distance of the VOR beacon. */ - NAV_VOR_DISTANCE: { + 'NAV VOR DISTANCE': { name: 'NAV VOR DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns the VOR station latitude, longitude and altitude. */ - 'NAV_VOR_LATLONALT:index': { + 'NAV VOR LATLONALT:index': { name: 'NAV VOR LATLONALT:index', - units: 'SIMCONNECT_DATA_LATLONALT structure', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Nav VOR latitude, longitude, altitude. */ - NAV_VOR_LLAF64: { + 'NAV VOR LLAF64': { name: 'NAV VOR LLAF64', - units: 'SIMCONNECT_DATA_LATLONALT structure', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The active channel used by the indexed Tacan receiver on the aircraft, from 1 to 127. */ - 'TACAN_ACTIVE_CHANNEL:index': { + /** The active channel used by the indexed Tacan receiver on the aircraft, from 1 to 127. */ + 'TACAN ACTIVE CHANNEL:index': { name: 'TACAN ACTIVE CHANNEL:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The active mode used by the indexed Tacan receiver on the aircraft, where 0 = X and 1 = Y. */ - 'TACAN_ACTIVE_MODE:index': { + /** The active mode used by the indexed Tacan receiver on the aircraft, where 0 = X and 1 = Y. */ + 'TACAN ACTIVE MODE:index': { name: 'TACAN ACTIVE MODE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Will be TRUE (1) if NAV1, NAV2, NAV3 or NAV4 can receive Tacan (depending on the index - 1, 2, 3, or 4), or FALSE (0) otherwise. */ - 'TACAN_AVAILABLE:index': { + /** Will be TRUE (1) if NAV1, NAV2, NAV3 or NAV4 can receive Tacan (depending on the index - 1, 2, 3, or 4), or FALSE (0) otherwise. */ + 'TACAN AVAILABLE:index': { name: 'TACAN AVAILABLE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Tells whether the Tacan is driving the -Nav 1 indicator (TRUE, 1) or not (FALSE, 0), for autopilot purposes. */ - 'TACAN_DRIVES_NAV1:index': { + /** Tells whether the Tacan is driving the Nav 1 indicator (TRUE, 1) or not (FALSE, 0), for autopilot purposes. */ + 'TACAN DRIVES NAV1:index': { name: 'TACAN DRIVES NAV1:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The Tacan OBS setting, in degrees. */ - 'TACAN_OBS:index': { + /** The Tacan OBS setting, in degrees. */ + 'TACAN OBS:index': { name: 'TACAN OBS:index', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The standby channel used by the indexed Tacan receiver on the aircraft, from 1 to 127. */ - 'TACAN_STANDBY_CHANNEL:index': { + /** The standby channel used by the indexed Tacan receiver on the aircraft, from 1 to 127. */ + 'TACAN STANDBY CHANNEL:index': { name: 'TACAN STANDBY CHANNEL:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Indicates -the indexed Tacan receiver standby mode, where 0 = X and 1 = Y. */ - 'TACAN_STANDBY_MODE:index': { + /** Indicates the indexed Tacan receiver standby mode, where 0 = X and 1 = Y. */ + 'TACAN STANDBY MODE:index': { name: 'TACAN STANDBY MODE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The CDI needle deflection amount(course deviation) to the station. Can be +/- 127. */ - 'TACAN_STATION_CDI:index': { + 'TACAN STATION CDI:index': { name: 'TACAN STATION CDI:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The distance between the Tacan station position and the aircraft position. The index value refers to the Tacan receiver connected to the station (1 or 2). */ - 'TACAN_STATION_DISTANCE:index': { + /** The distance between the Tacan station position and the aircraft position. The index value refers to the Tacan receiver connected to the station (1 or 2). */ + 'TACAN STATION DISTANCE:index': { name: 'TACAN STATION DISTANCE:index', units: 'Meter', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The tuned station identifier for the indexed Tacan. */ - 'TACAN_STATION_IDENT:index': { + /** The tuned station identifier for the indexed Tacan. */ + 'TACAN STATION IDENT:index': { name: 'TACAN STATION IDENT:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** Retrieves the latitude, longitude and altitude of the Tacan station. */ - 'TACAN_STATION_LATLONALT:index': { + /** Retrieves the latitude, longitude and altitude of the Tacan station. */ + 'TACAN STATION LATLONALT:index': { name: 'TACAN STATION LATLONALT:index', - units: 'SIMCONNECT_DATA_LATLONALT', - dataType: SimConnectDataType.LATLONALT, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The radial between the Tacan station and the aircraft. */ - 'TACAN_STATION_RADIAL:index': { + /** The radial between the Tacan station and the aircraft. */ + 'TACAN STATION RADIAL:index': { name: 'TACAN STATION RADIAL:index', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Difference between the current radial and OBS tuned radial, in degrees. */ - 'TACAN_STATION_RADIAL_ERROR:index': { + 'TACAN STATION RADIAL ERROR:index': { name: 'TACAN STATION RADIAL ERROR:index', units: 'Degrees.', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns whether the indexed Tacan is going to or from the current radial (or is off). */ - 'TACAN_STATION_TOFROM:index': { + /** Returns whether the indexed Tacan is going to or from the current radial (or is off). */ + 'TACAN STATION TOFROM:index': { name: 'TACAN STATION TOFROM:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** The volume value of the indexed Tacan receiver on the aircraft. */ - 'TACAN_VOLUME:index': { + /** The volume value of the indexed Tacan receiver on the aircraft. */ + 'TACAN VOLUME:index': { name: 'TACAN VOLUME:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** On which channel the copilot is transmitting. */ - COPILOT_TRANSMITTER_TYPE: { + 'COPILOT TRANSMITTER TYPE': { name: 'COPILOT TRANSMITTER TYPE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not the copilot is transmitting. */ - COPILOT_TRANSMITTING: { + 'COPILOT TRANSMITTING': { name: 'COPILOT TRANSMITTING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** On which channel the pilot is transmitting. */ - PILOT_TRANSMITTER_TYPE: { + 'PILOT TRANSMITTER TYPE': { name: 'PILOT TRANSMITTER TYPE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not the pilot is transmitting. */ - PILOT_TRANSMITTING: { + 'PILOT TRANSMITTING': { name: 'PILOT TRANSMITTING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Currently not used within the simulation. */ - RADIOS_AVAILABLE: { + /** Currently not used within the simulation. */ + 'RADIOS AVAILABLE': { name: 'RADIOS AVAILABLE', units: '-', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Radar altitude. */ - RADIO_HEIGHT: { + 'RADIO HEIGHT': { name: 'RADIO HEIGHT', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if a transponder is available. */ - TRANSPONDER_AVAILABLE: { + 'TRANSPONDER AVAILABLE': { name: 'TRANSPONDER AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** 4-digit code. */ - 'TRANSPONDER_CODE:index': { + 'TRANSPONDER CODE:index': { name: 'TRANSPONDER CODE:index', units: 'BCD16', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** This can set the Ident transponder using the KEY_XPNDR_IDENT_SET, KEY_XPNDR_IDENT_TOGGLE, KEY_XPNDR_IDENT_ON or KEY_XPNDR_IDENT_OFF Event IDs (see XPNDR (Transponder) section for more information). When set to true, it will automatically turn false after 18 seconds. */ - TRANSPONDER_IDENT: { + /** This can set the Ident transponder using the KEY_XPNDR_IDENT_SET, KEY_XPNDR_IDENT_TOGGLE, KEY_XPNDR_IDENT_ON or KEY_XPNDR_IDENT_OFF Event IDs (see XPNDR (Transponder) section for more information). When set to true, it will automatically turn false after 18 seconds. */ + 'TRANSPONDER IDENT': { name: 'TRANSPONDER IDENT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Transponder State. */ - TRANSPONDER_STATE: { + 'TRANSPONDER STATE': { name: 'TRANSPONDER STATE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Angle of True calibration scale on airspeed indicator. */ - AIRSPEED_TRUE_CALIBRATE: { + 'AIRSPEED TRUE CALIBRATE': { name: 'AIRSPEED TRUE CALIBRATE', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Alternate static air source. */ - 'ALTERNATE_STATIC_SOURCE_OPEN:index': { + 'ALTERNATE STATIC SOURCE OPEN:index': { name: 'ALTERNATE STATIC SOURCE OPEN:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Anemometer rpm as a percentage. */ - ANEMOMETER_PCT_RPM: { + 'ANEMOMETER PCT RPM': { name: 'ANEMOMETER PCT RPM', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** AoA indication. */ - ANGLE_OF_ATTACK_INDICATOR: { + /** AoA indication. */ + 'ANGLE OF ATTACK INDICATOR': { name: 'ANGLE OF ATTACK INDICATOR', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Currently not used in the simulation. */ - ANNUNCIATOR_SWITCH: { + /** Currently not used in the simulation. */ + 'ANNUNCIATOR SWITCH': { name: 'ANNUNCIATOR SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Used when too close to a fire. */ - APPLY_HEAT_TO_SYSTEMS: { + 'APPLY HEAT TO SYSTEMS': { name: 'APPLY HEAT TO SYSTEMS', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** True if the audio panel is available. */ - AUDIO_PANEL_AVAILABLE: { + 'AUDIO PANEL AVAILABLE': { name: 'AUDIO PANEL AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The Volume of the Audio Panel. */ - AUDIO_PANEL_VOLUME: { + 'AUDIO PANEL VOLUME': { name: 'AUDIO PANEL VOLUME', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Auto-throttle active. */ - AUTOTHROTTLE_ACTIVE: { + 'AUTOTHROTTLE ACTIVE': { name: 'AUTOTHROTTLE ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is auto-coordination active. */ - AUTO_COORDINATION: { + 'AUTO COORDINATION': { name: 'AUTO COORDINATION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** The avionics master switch position, true if the switch is ON. Use an avionics circuit index when referencing. */ - 'AVIONICS_MASTER_SWITCH:index': { + /** The avionics master switch position, true if the switch is ON. Use an avionics circuit index when referencing. */ + 'AVIONICS MASTER SWITCH:index': { name: 'AVIONICS MASTER SWITCH:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the No Smoking switch is on. */ - CABIN_NO_SMOKING_ALERT_SWITCH: { + 'CABIN NO SMOKING ALERT SWITCH': { name: 'CABIN NO SMOKING ALERT SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the Seatbelts switch is on. */ - CABIN_SEATBELTS_ALERT_SWITCH: { + 'CABIN SEATBELTS ALERT SWITCH': { name: 'CABIN SEATBELTS ALERT SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Percent primary door/exit open. */ - CANOPY_OPEN: { + 'CANOPY OPEN': { name: 'CANOPY OPEN', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** True if carburetor -heat available. */ - CARB_HEAT_AVAILABLE: { + /** True if carburetor heat available. */ + 'CARB HEAT AVAILABLE': { name: 'CARB HEAT AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Rate of turn of heading indicator. */ - DELTA_HEADING_RATE: { + 'DELTA HEADING RATE': { name: 'DELTA HEADING RATE', units: 'Radians per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** DME audio flag. */ - DME_SOUND: { + /** DME audio flag. */ + 'DME SOUND': { name: 'DME SOUND', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not the Emergency Locator Transmitter is active. */ - ELT_ACTIVATED: { + 'ELT ACTIVATED': { name: 'ELT ACTIVATED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Generic SimVar. */ - EXTERNAL_SYSTEM_VALUE: { + 'EXTERNAL SYSTEM VALUE': { name: 'EXTERNAL SYSTEM VALUE', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** True if the fire bottle is discharged. */ - FIRE_BOTTLE_DISCHARGED: { + 'FIRE BOTTLE DISCHARGED': { name: 'FIRE BOTTLE DISCHARGED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the fire bottle switch is on. */ - FIRE_BOTTLE_SWITCH: { + 'FIRE BOTTLE SWITCH': { name: 'FIRE BOTTLE SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** This variable will return a value between 0 and 1 for the automatic brightness setting for glass cockpit displays, where 0 is the dimmest and 1 is the brightest. This value will vary depending on the time of day. */ - GLASSCOCKPIT_AUTOMATIC_BRIGHTNESS: { + 'GLASSCOCKPIT AUTOMATIC BRIGHTNESS': { name: 'GLASSCOCKPIT AUTOMATIC BRIGHTNESS', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if the Ground Proximity Warning System is active. */ - GPWS_SYSTEM_ACTIVE: { + 'GPWS SYSTEM ACTIVE': { name: 'GPWS SYSTEM ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** True if Ground Proximity Warning System installed. */ - GPWS_WARNING: { + 'GPWS WARNING': { name: 'GPWS WARNING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Angular error of heading indicator. */ - GYRO_DRIFT_ERROR: { + 'GYRO DRIFT ERROR': { name: 'GYRO DRIFT ERROR', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Will return whether the aircraft has stall protection (true) or not (false). */ - HAS_STALL_PROTECTION: { + 'HAS STALL PROTECTION': { name: 'HAS STALL PROTECTION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Heading indicator (directional gyro) indication. */ - HEADING_INDICATOR: { + 'HEADING INDICATOR': { name: 'HEADING INDICATOR', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The indicated altitude. */ - INDICATED_ALTITUDE: { + 'INDICATED ALTITUDE': { name: 'INDICATED ALTITUDE', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Indicated altitude with the altimeter calibrated to current sea level pressure. */ - INDICATED_ALTITUDE_CALIBRATED: { + 'INDICATED ALTITUDE CALIBRATED': { name: 'INDICATED ALTITUDE CALIBRATED', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Similar to INDICATED_ALTITUDE but doesn't affect actual plane position when setting this variable. */ - INDICATED_ALTITUDE_EX1: { + /** Similar to INDICATED_ALTITUDE but doesn't affect actual plane position when setting this variable. */ + 'INDICATED ALTITUDE EX1': { name: 'INDICATED ALTITUDE EX1', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Inductor compass heading. */ - INDUCTOR_COMPASS_HEADING_REF: { + 'INDUCTOR COMPASS HEADING REF': { name: 'INDUCTOR COMPASS HEADING REF', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Inductor compass deviation reading. */ - INDUCTOR_COMPASS_PERCENT_DEVIATION: { + 'INDUCTOR COMPASS PERCENT DEVIATION': { name: 'INDUCTOR COMPASS PERCENT DEVIATION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, do not use! */ - INSTRUMENTS_AVAILABLE: { + /** Deprecated, do not use! */ + 'INSTRUMENTS AVAILABLE': { name: 'INSTRUMENTS AVAILABLE', units: 'Mask', dataType: SimConnectDataType.INT32, settable: false, }, /** Intercom Mode */ - INTERCOM_MODE: { + 'INTERCOM MODE': { name: 'INTERCOM MODE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Whether or not the intercom system is active. */ - INTERCOM_SYSTEM_ACTIVE: { + 'INTERCOM SYSTEM ACTIVE': { name: 'INTERCOM SYSTEM ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the altitude of the aircraft is frozen. */ - IS_ALTITUDE_FREEZE_ON: { + 'IS ALTITUDE FREEZE ON': { name: 'IS ALTITUDE FREEZE ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the attitude (pitch, bank and heading) of the aircraft is frozen. */ - IS_ATTITUDE_FREEZE_ON: { + 'IS ATTITUDE FREEZE ON': { name: 'IS ATTITUDE FREEZE ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** True if the lat/lon of the aircraft (either user or AI controlled) is frozen. If this variable returns true, it means that the latitude and longitude of the aircraft are not being controlled by ESP, so enabling, for example, a SimConnect client to control the position of the aircraft. This can also apply to altitude and attitude. - - Also refer to the range of KEY_FREEZE..... Event IDs. */ - IS_LATITUDE_LONGITUDE_FREEZE_ON: { + /** True if the lat/lon of the aircraft (either user or AI controlled) is frozen. If this variable returns true, it means that the latitude and longitude of the aircraft are not being controlled by ESP, so enabling, for example, a SimConnect client to control the position of the aircraft. This can also apply to altitude and attitude.
+
+ Also refer to the range of KEY_FREEZE..... Event IDs. + */ + 'IS LATITUDE LONGITUDE FREEZE ON': { name: 'IS LATITUDE LONGITUDE FREEZE ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The value for the given altimeter index in inches of mercury. - IMPORTANT! In the system.cfg file, altimeters are indexed from 0, but the SimVar indexes from 1. So, altimeter 0 in that file is accessed using KOHLSMAN SETTING HG:1, 1 by KOHLSMAN SETTING HG:2, etc... */ - 'KOHLSMAN_SETTING_HG:index': { + /** +

The value for the given altimeter index in inches of mercury.

+

IMPORTANT! In the system.cfg file, altimeters are indexed from 0, but the SimVar indexes from 1. So, altimeter 0 in that file is accessed using KOHLSMAN SETTING HG:1, 1 by KOHLSMAN SETTING HG:2, etc...

+ */ + 'KOHLSMAN SETTING HG:index': { name: 'KOHLSMAN SETTING HG:index', units: 'Inches of Mercury, inHg', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The value for the given altimeter index in millibars. - IMPORTANT! In the system.cfg file, altimeters are indexed from 0, but the SimVar indexes from 1. So, altimeter 0 in that file is accessed using KOHLSMAN SETTING MB:1, 1 by KOHLSMAN SETTING MB:2, etc... */ - 'KOHLSMAN_SETTING_MB:index': { + /** +

The value for the given altimeter index in millibars.

+

IMPORTANT! In the system.cfg file, altimeters are indexed from 0, but the SimVar indexes from 1. So, altimeter 0 in that file is accessed using KOHLSMAN SETTING MB:1, 1 by KOHLSMAN SETTING MB:2, etc...

+ */ + 'KOHLSMAN SETTING MB:index': { name: 'KOHLSMAN SETTING MB:index', units: 'Millibars', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** True if the indexed altimeter is in "Standard" mode, or false otherwise. - IMPORTANT! In the system.cfg file, altimeters are indexed from 0, but the SimVar indexes from 1. So, altimeter 0 in that file is accessed using KOHLSMAN SETTING STD:1, 1 by KOHLSMAN SETTING STD:2, etc... */ - 'KOHLSMAN_SETTING_STD:index': { + /** +

True if the indexed altimeter is in "Standard" mode, or false otherwise.

+

IMPORTANT! In the system.cfg file, altimeters are indexed from 0, but the SimVar indexes from 1. So, altimeter 0 in that file is accessed using KOHLSMAN SETTING STD:1, 1 by KOHLSMAN SETTING STD:2, etc...

+ */ + 'KOHLSMAN SETTING STD:index': { name: 'KOHLSMAN SETTING STD:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Compass reading. */ - MAGNETIC_COMPASS: { + 'MAGNETIC COMPASS': { name: 'MAGNETIC COMPASS', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Position of manual fuel pump handle. 1 is fully deployed. */ - MANUAL_FUEL_PUMP_HANDLE: { + 'MANUAL FUEL PUMP HANDLE': { name: 'MANUAL FUEL PUMP HANDLE', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Overspeed warning state. */ - OVERSPEED_WARNING: { + 'OVERSPEED WARNING': { name: 'OVERSPEED WARNING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if panel anti-ice switch is on. */ - PANEL_ANTI_ICE_SWITCH: { + 'PANEL ANTI ICE SWITCH': { name: 'PANEL ANTI ICE SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Amount of pitot ice. 100 is fully iced. */ - PITOT_ICE_PCT: { + 'PITOT ICE PCT': { name: 'PITOT ICE PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Pitot heat active. */ - PITOT_HEAT: { + 'PITOT HEAT': { name: 'PITOT HEAT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Pitot heat switch state. */ - 'PITOT_HEAT_SWITCH:index': { + 'PITOT HEAT SWITCH:index': { name: 'PITOT HEAT SWITCH:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, - /** Standard Altitude, ie: at a 1013.25 hPa (1 atmosphere) setting. */ - PRESSURE_ALTITUDE: { + /** Standard Altitude, ie: at a 1013.25 hPa (1 atmosphere) setting. */ + 'PRESSURE ALTITUDE': { name: 'PRESSURE ALTITUDE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The current altitude of the cabin pressurization. */ - PRESSURIZATION_CABIN_ALTITUDE: { + /** +

The current altitude of the cabin pressurization.

+ */ + 'PRESSURIZATION CABIN ALTITUDE': { name: 'PRESSURIZATION CABIN ALTITUDE', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The set altitude of the cabin pressurization as initialised from the Design Cabin Pressure value in the systems.cfg file. Pressure is converted into an altitude using a standard condition table. - You can adjust the goal pressure using the -PRESSURIZATION_PRESSURE_ALT_INC and -PRESSURIZATION_PRESSURE_ALT_DEC events. */ - PRESSURIZATION_CABIN_ALTITUDE_GOAL: { + /** +

The set altitude of the cabin pressurization as initialised from the Design Cabin Pressure value in the systems.cfg file. Pressure is converted into an altitude using a standard condition table.

+

You can adjust the goal pressure using the PRESSURIZATION_PRESSURE_ALT_INC and PRESSURIZATION_PRESSURE_ALT_DEC events.

+ */ + 'PRESSURIZATION CABIN ALTITUDE GOAL': { name: 'PRESSURIZATION CABIN ALTITUDE GOAL', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The rate at which cabin pressurization changes. */ - PRESSURIZATION_CABIN_ALTITUDE_RATE: { + 'PRESSURIZATION CABIN ALTITUDE RATE': { name: 'PRESSURIZATION CABIN ALTITUDE RATE', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if the cabin pressurization dump switch is on. */ - PRESSURIZATION_DUMP_SWITCH: { + 'PRESSURIZATION DUMP SWITCH': { name: 'PRESSURIZATION DUMP SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The difference in pressure between the set altitude pressurization and the current pressurization. */ - PRESSURIZATION_PRESSURE_DIFFERENTIAL: { + 'PRESSURIZATION PRESSURE DIFFERENTIAL': { name: 'PRESSURIZATION PRESSURE DIFFERENTIAL', units: 'Pounds per square foot, psf', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if Rad INS switch on. */ - RAD_INS_SWITCH: { + 'RAD INS SWITCH': { name: 'RAD INS SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Selected DME. */ - SELECTED_DME: { + 'SELECTED DME': { name: 'SELECTED DME', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Smoke system available. - NOTE: There is no default "smoke system" that this SimVar works on and this is a legacy variable that is available for use should you wish to use it but it affects nothing by default. */ - SMOKESYSTEM_AVAILABLE: { + /** +

Smoke system available.

+

NOTE: There is no default "smoke system" that this SimVar works on and this is a legacy variable that is available for use should you wish to use it but it affects nothing by default.

+ */ + 'SMOKESYSTEM AVAILABLE': { name: 'SMOKESYSTEM AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Set to True to activate the smoke system, if one is available. Please see the notes for SMOKESYSTEM AVAILABLE for more information. */ - SMOKE_ENABLE: { + /** +

Set to True to activate the smoke system, if one is available. Please see the notes for SMOKESYSTEM AVAILABLE for more information.

+ */ + 'SMOKE ENABLE': { name: 'SMOKE ENABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Whether or not the speaker is active. */ - SPEAKER_ACTIVE: { + 'SPEAKER ACTIVE': { name: 'SPEAKER ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if stall alarm available. */ - STALL_HORN_AVAILABLE: { + 'STALL HORN AVAILABLE': { name: 'STALL HORN AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Alpha below which the Stall Protection can be disabled. See the [STALL PROTECTION] section for more information. */ - STALL_PROTECTION_OFF_LIMIT: { + /** Alpha below which the Stall Protection can be disabled. See the [STALL PROTECTION] section for more information. */ + 'STALL PROTECTION OFF LIMIT': { name: 'STALL PROTECTION OFF LIMIT', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The alpha that the Stall Protection will attempt to reach when triggered. See the [STALL PROTECTION] section for more information. */ - STALL_PROTECTION_ON_GOAL: { + /** The alpha that the Stall Protection will attempt to reach when triggered. See the [STALL PROTECTION] section for more information. */ + 'STALL PROTECTION ON GOAL': { name: 'STALL PROTECTION ON GOAL', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Alpha above which the Stall Protection timer starts. See the [STALL PROTECTION] section for more information. */ - STALL_PROTECTION_ON_LIMIT: { + /** Alpha above which the Stall Protection timer starts. See the [STALL PROTECTION] section for more information. */ + 'STALL PROTECTION ON LIMIT': { name: 'STALL PROTECTION ON LIMIT', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Stall warning state. */ - STALL_WARNING: { + 'STALL WARNING': { name: 'STALL WARNING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the aircraft structure deice switch is on. */ - STRUCTURAL_DEICE_SWITCH: { + 'STRUCTURAL DEICE SWITCH': { name: 'STRUCTURAL DEICE SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Vacuum system suction pressure. */ - SUCTION_PRESSURE: { + 'SUCTION PRESSURE': { name: 'SUCTION PRESSURE', units: 'Inches of Mercury, inHg', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Deprecated, do not use! */ - SYSTEMS_AVAILABLE: { + /** Deprecated, do not use! */ + 'SYSTEMS AVAILABLE': { name: 'SYSTEMS AVAILABLE', units: 'Mask', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the tailhook handle is engaged. */ - TAILHOOK_HANDLE: { + 'TAILHOOK HANDLE': { name: 'TAILHOOK HANDLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Percent tail hook extended. */ - TAILHOOK_POSITION: { + 'TAILHOOK POSITION': { name: 'TAILHOOK POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Position of tow release handle. 100 is fully deployed. */ - TOW_RELEASE_HANDLE: { + 'TOW RELEASE HANDLE': { name: 'TOW RELEASE HANDLE', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if True Airspeed has been selected. */ - TRUE_AIRSPEED_SELECTED: { + 'TRUE AIRSPEED SELECTED': { name: 'TRUE AIRSPEED SELECTED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Turn coordinator ball position. */ - TURN_COORDINATOR_BALL: { + 'TURN COORDINATOR BALL': { name: 'TURN COORDINATOR BALL', - units: 'Position 128', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Turn coordinator ball position inverted (upside down). */ - TURN_COORDINATOR_BALL_INV: { + 'TURN COORDINATOR BALL INV': { name: 'TURN COORDINATOR BALL INV', - units: 'Position 128', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Turn indicator reading. - NOTE: This is available in multiplayer to all -near -aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - TURN_INDICATOR_RATE: { + /** +

Turn indicator reading.

+

NOTE: This is available in multiplayer to all near aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'TURN INDICATOR RATE': { name: 'TURN INDICATOR RATE', units: 'Radians per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if turn indicator switch is on. */ - TURN_INDICATOR_SWITCH: { + 'TURN INDICATOR SWITCH': { name: 'TURN INDICATOR SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if the aircraft windshield deice switch is on. */ - WINDSHIELD_DEICE_SWITCH: { + 'WINDSHIELD DEICE SWITCH': { name: 'WINDSHIELD DEICE SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Deprecated, do not use! - Use MAGNETIC_COMPASS instead. */ - WISKEY_COMPASS_INDICATION_DEGREES: { + /** +

Deprecated, do not use!

+

Use MAGNETIC_COMPASS instead.

+ */ + 'WISKEY COMPASS INDICATION DEGREES': { name: 'WISKEY COMPASS INDICATION DEGREES', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The MacCready setting used to fly an optimal speed between thermals. */ - VARIOMETER_MAC_CREADY_SETTING: { + 'VARIOMETER MAC CREADY SETTING': { name: 'VARIOMETER MAC CREADY SETTING', units: 'Meters per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Variometer rate using Netto (Total Energy - polar sinkRate). */ - VARIOMETER_NETTO: { + 'VARIOMETER NETTO': { name: 'VARIOMETER NETTO', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The variometer rate. */ - VARIOMETER_RATE: { + 'VARIOMETER RATE': { name: 'VARIOMETER RATE', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Optimal speed to fly between thermals using polar curve and MacCready setting. */ - VARIOMETER_SPEED_TO_FLY: { + 'VARIOMETER SPEED TO FLY': { name: 'VARIOMETER SPEED TO FLY', units: 'Kilometers per hour', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The glide ratio at optimal speed to fly. */ - VARIOMETER_SPEED_TO_FLY_GLIDE_RATIO: { + 'VARIOMETER SPEED TO FLY GLIDE RATIO': { name: 'VARIOMETER SPEED TO FLY GLIDE RATIO', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if the variometer switch is on, false if it is not. */ - VARIOMETER_SWITCH: { + 'VARIOMETER SWITCH': { name: 'VARIOMETER SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The variometer rate using total energy. - Total Energy = Potential Energy + Kinetic Energy */ - VARIOMETER_TOTAL_ENERGY: { + /** +

The variometer rate using total energy.

+ 
Total Energy = Potential Energy + Kinetic Energy
+ */ + 'VARIOMETER TOTAL ENERGY': { name: 'VARIOMETER TOTAL ENERGY', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The capacity of the indexed water ballast tank. */ - 'WATER_BALLAST_TANK_CAPACITY:index': { + 'WATER BALLAST TANK CAPACITY:index': { name: 'WATER BALLAST TANK CAPACITY:index', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The number of water ballast tank available. */ - WATER_BALLAST_TANK_NUMBER: { + 'WATER BALLAST TANK NUMBER': { name: 'WATER BALLAST TANK NUMBER', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The quantity of water ballast in the indexed tank. */ - 'WATER_BALLAST_TANK_QUANTITY:index': { + 'WATER BALLAST TANK QUANTITY:index': { name: 'WATER BALLAST TANK QUANTITY:index', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True (1) if a water ballast valve is available, False (0) otherwise. */ - WATER_BALLAST_VALVE: { + 'WATER BALLAST VALVE': { name: 'WATER BALLAST VALVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The flow rate of the water ballast valve. */ - WATER_BALLAST_VALVE_FLOW_RATE: { + 'WATER BALLAST VALVE FLOW RATE': { name: 'WATER BALLAST VALVE FLOW RATE', units: 'Gallons per hour', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This variable will return 1 (TRUE) if all the ballast tank valves are open, or 0 (FALSE) otherwise. */ - WATER_BALLAST_EVERY_VALVE_OPEN: { + 'WATER BALLAST EVERY VALVE OPEN': { name: 'WATER BALLAST EVERY VALVE OPEN', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Will return true if any interior light is on or false otherwise. */ - IS_ANY_INTERIOR_LIGHT_ON: { + 'IS ANY INTERIOR LIGHT ON': { name: 'IS ANY INTERIOR LIGHT ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Landing light pitch bank and heading. */ - LANDING_LIGHT_PBH: { + 'LANDING LIGHT PBH': { name: 'LANDING LIGHT PBH', - units: 'SIMCONNECT_DATA_XYZ structure', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Light switch state. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_BEACON: { + /** +

Light switch state.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT BEACON': { name: 'LIGHT BEACON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target beacon light is functioning or if the switch is ON. Use beacon lightdef index. */ - LIGHT_BEACON_ON: { + /** Returns true if the target beacon light is functioning or if the switch is ON. Use beacon lightdef index. */ + 'LIGHT BEACON ON': { name: 'LIGHT BEACON ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Vehicle backlights current intensity (0 = off, 1 = full intensity). */ - LIGHT_BACKLIGHT_INTENSITY: { + 'LIGHT BACKLIGHT INTENSITY': { name: 'LIGHT BACKLIGHT INTENSITY', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Returns true if the target brake light is functioning or if the switch is ON. */ - LIGHT_BRAKE_ON: { + /** Returns true if the target brake light is functioning or if the switch is ON. */ + 'LIGHT BRAKE ON': { name: 'LIGHT BRAKE ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Light switch state. */ - LIGHT_CABIN: { + 'LIGHT CABIN': { name: 'LIGHT CABIN', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target cabin light is functioning or if the switch is ON. Use the cabin lightdef index. */ - LIGHT_CABIN_ON: { + /** Returns true if the target cabin light is functioning or if the switch is ON. Use the cabin lightdef index. */ + 'LIGHT CABIN ON': { name: 'LIGHT CABIN ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The current cabin light power setting. Requires the cabin lightdef index. */ - LIGHT_CABIN_POWER_SETTING: { + /** The current cabin light power setting. Requires the cabin lightdef index. */ + 'LIGHT CABIN POWER SETTING': { name: 'LIGHT CABIN POWER SETTING', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Whether or not the Light switch for the Glareshield is enabled. */ - LIGHT_GLARESHIELD: { + 'LIGHT GLARESHIELD': { name: 'LIGHT GLARESHIELD', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target glareshield light is functioning or if the switch is ON. Use the glareshield lightdef index. */ - LIGHT_GLARESHIELD_ON: { + /** Returns true if the target glareshield light is functioning or if the switch is ON. Use the glareshield lightdef index. */ + 'LIGHT GLARESHIELD ON': { name: 'LIGHT GLARESHIELD ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The current glareshield light power setting. Requires the glareshield lightdef index. */ - LIGHT_GLARESHIELD_POWER_SETTING: { + /** The current glareshield light power setting. Requires the glareshield lightdef index. */ + 'LIGHT GLARESHIELD POWER SETTING': { name: 'LIGHT GLARESHIELD POWER SETTING', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Vehicle gyrolights current intensity (0 = off, 1 = full intensity). */ - LIGHT_GYROLIGHT_INTENSITY: { + 'LIGHT GYROLIGHT INTENSITY': { name: 'LIGHT GYROLIGHT INTENSITY', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Returns true if the target navigation light is functioning or if the switch is ON. */ - LIGHT_HEAD_ON: { + /** Returns true if the target navigation light is functioning or if the switch is ON. */ + 'LIGHT HEAD ON': { name: 'LIGHT HEAD ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Vehicle headlights current intensity (0 = off, 1 = full intensity). */ - LIGHT_HEADLIGHT_INTENSITY: { + 'LIGHT HEADLIGHT INTENSITY': { name: 'LIGHT HEADLIGHT INTENSITY', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Returns true if the target landing light is functioning or if the switch is ON. Use landing lightdef index. */ - LIGHT_LANDING_ON: { + /** Returns true if the target landing light is functioning or if the switch is ON. Use landing lightdef index. */ + 'LIGHT LANDING ON': { name: 'LIGHT LANDING ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Light switch state for landing light. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_LANDING: { + /** +

Light switch state for landing light.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT LANDING': { name: 'LIGHT LANDING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Light switch state for logo light. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_LOGO: { + /** +

Light switch state for logo light.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT LOGO': { name: 'LIGHT LOGO', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target logo light is functioning or if the switch is ON. Use the logo lightdef index. */ - LIGHT_LOGO_ON: { + /** Returns true if the target logo light is functioning or if the switch is ON. Use the logo lightdef index. */ + 'LIGHT LOGO ON': { name: 'LIGHT LOGO ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Returns true if the target navigation light is functioning or if the switch is ON. Use navigation lightdef index. */ - LIGHT_NAV_ON: { + /** Returns true if the target navigation light is functioning or if the switch is ON. Use navigation lightdef index. */ + 'LIGHT NAV ON': { name: 'LIGHT NAV ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Light switch state for the NAV light. */ - LIGHT_NAV: { + 'LIGHT NAV': { name: 'LIGHT NAV', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Bit mask:[index] - - 0x0001:[index] Nav - 0x0002:[index] Beacon - 0x0004:[index] Landing - 0x0008:[index] Taxi - 0x0010:[index] Strobe - 0x0020:[index] Panel - 0x0040:[index] Recognition - 0x0080:[index] Wing - 0x0100:[index] Logo - 0x0200:[index] Cabin */ - LIGHT_ON_STATES: { + /** +

Bit mask:[index]

+
    +
  1. 0x0001:[index] Nav
    2. +
  2. 0x0002:[index] Beacon
    3. +
  3. 0x0004:[index] Landing
    4. +
  4. 0x0008:[index] Taxi
    5. +
  5. 0x0010:[index] Strobe
    6. +
  6. 0x0020:[index] Panel
    7. +
  7. 0x0040:[index] Recognition
    8. +
  8. 0x0080:[index] Wing
    9. +
  9. 0x0100:[index] Logo
    10. +
  10. 0x0200:[index] Cabin
    11. +
+ */ + 'LIGHT ON STATES': { name: 'LIGHT ON STATES', units: 'Mask', dataType: SimConnectDataType.INT32, settable: false, }, /** Light switch state of the panel light. */ - LIGHT_PANEL: { + 'LIGHT PANEL': { name: 'LIGHT PANEL', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target panel light is functioning or if the switch is ON. Use the panel lightdef index. */ - LIGHT_PANEL_ON: { + /** Returns true if the target panel light is functioning or if the switch is ON. Use the panel lightdef index. */ + 'LIGHT PANEL ON': { name: 'LIGHT PANEL ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The current panel light power setting. Requires the panel lightdef index. */ - LIGHT_PANEL_POWER_SETTING: { + /** The current panel light power setting. Requires the panel lightdef index. */ + 'LIGHT PANEL POWER SETTING': { name: 'LIGHT PANEL POWER SETTING', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Whether or not the Light switch for the Pedestal is enabled. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_PEDESTRAL: { + /** +

Whether or not the Light switch for the Pedestal is enabled.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT PEDESTRAL': { name: 'LIGHT PEDESTRAL', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target pedestral light is functioning or if the switch is ON. Requires the pedestral lightdef index. */ - LIGHT_PEDESTRAL_ON: { + /** +

Returns true if the target pedestral light is functioning or if the switch is ON. Requires the pedestral lightdef index.

+ */ + 'LIGHT PEDESTRAL ON': { name: 'LIGHT PEDESTRAL ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The current pedestral light power setting. Requires the pedestral lightdef index. */ - LIGHT_PEDESTRAL_POWER_SETTING: { + /** The current pedestral light power setting. Requires the pedestral lightdef index. */ + 'LIGHT PEDESTRAL POWER SETTING': { name: 'LIGHT PEDESTRAL POWER SETTING', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Adjust the potentiometer of the indexed lighting. Index is defined in the appropriate lightdef hashmap setting. */ - 'LIGHT_POTENTIOMETER:index': { + /** Adjust the potentiometer of the indexed lighting. Index is defined in the appropriate lightdef hashmap setting. */ + 'LIGHT POTENTIOMETER:index': { name: 'LIGHT POTENTIOMETER:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Light switch state for the recognition light. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_RECOGNITION: { + /** +

Light switch state for the recognition light.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT RECOGNITION': { name: 'LIGHT RECOGNITION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target recognition light is functioning or if the switch is ON. Use the recognition lightdef index. */ - LIGHT_RECOGNITION_ON: { + /** Returns true if the target recognition light is functioning or if the switch is ON. Use the recognition lightdef index. */ + 'LIGHT RECOGNITION ON': { name: 'LIGHT RECOGNITION ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Same as LIGHT_ON_STATES. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_STATES: { + /** +

Same as LIGHT_ON_STATES.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT STATES': { name: 'LIGHT STATES', units: 'Mask', dataType: SimConnectDataType.INT32, settable: false, }, - /** Light switch state for the strobe lights. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_STROBE: { + /** +

Light switch state for the strobe lights.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT STROBE': { name: 'LIGHT STROBE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target strobe light is functioning or if the switch is ON. Use the strobe lightdef index. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_STROBE_ON: { + /** +

Returns true if the target strobe light is functioning or if the switch is ON. Use the strobe lightdef index.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT STROBE ON': { name: 'LIGHT STROBE ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Light switch state for the taxi light. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_TAXI: { + /** +

Light switch state for the taxi light.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT TAXI': { name: 'LIGHT TAXI', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target taxi light is functioning or if the switch is ON. Use taxi lightdef index. */ - LIGHT_TAXI_ON: { + /** Returns true if the target taxi light is functioning or if the switch is ON. Use taxi lightdef index. */ + 'LIGHT TAXI ON': { name: 'LIGHT TAXI ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Light switch state for the wing lights. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - LIGHT_WING: { + /** +

Light switch state for the wing lights.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'LIGHT WING': { name: 'LIGHT WING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if the target wing light is functioning or if the switch is ON. Use the wing lightdef index. */ - LIGHT_WING_ON: { + /** Returns true if the target wing light is functioning or if the switch is ON. Use the wing lightdef index. */ + 'LIGHT WING ON': { name: 'LIGHT WING ON', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if instrument lights are set manually. */ - MANUAL_INSTRUMENT_LIGHTS: { + 'MANUAL INSTRUMENT LIGHTS': { name: 'MANUAL INSTRUMENT LIGHTS', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True if strobe lights are available. */ - STROBES_AVAILABLE: { + 'STROBES AVAILABLE': { name: 'STROBES AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Deprecated, do not use! */ - STROBE_FLASH: { + /** Deprecated, do not use! */ + 'STROBE FLASH': { name: 'STROBE FLASH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Hydraulic system pressure. Indexes start at 1. */ - 'HYDRAULIC_PRESSURE:index': { + 'HYDRAULIC PRESSURE:index': { name: 'HYDRAULIC PRESSURE:index', units: 'Pound force per square foot', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Hydraulic pressure changes will follow changes to this variable. Indexes start at 1. */ - 'HYDRAULIC_RESERVOIR_PERCENT:index': { + 'HYDRAULIC RESERVOIR PERCENT:index': { name: 'HYDRAULIC RESERVOIR PERCENT:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** True if hydraulic switch is on. */ - HYDRAULIC_SWITCH: { + 'HYDRAULIC SWITCH': { name: 'HYDRAULIC SWITCH', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Percent system functional. */ - HYDRAULIC_SYSTEM_INTEGRITY: { + 'HYDRAULIC SYSTEM INTEGRITY': { name: 'HYDRAULIC SYSTEM INTEGRITY', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Gauge fail flag. */ - PARTIAL_PANEL_ADF: { + 'PARTIAL PANEL ADF': { name: 'PARTIAL PANEL ADF', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_AIRSPEED: { + 'PARTIAL PANEL AIRSPEED': { name: 'PARTIAL PANEL AIRSPEED', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_ALTIMETER: { + 'PARTIAL PANEL ALTIMETER': { name: 'PARTIAL PANEL ALTIMETER', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_ATTITUDE: { + 'PARTIAL PANEL ATTITUDE': { name: 'PARTIAL PANEL ATTITUDE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_AVIONICS: { + 'PARTIAL PANEL AVIONICS': { name: 'PARTIAL PANEL AVIONICS', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Gauge fail flag. */ - PARTIAL_PANEL_COMM: { + 'PARTIAL PANEL COMM': { name: 'PARTIAL PANEL COMM', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_COMPASS: { + 'PARTIAL PANEL COMPASS': { name: 'PARTIAL PANEL COMPASS', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_ELECTRICAL: { + 'PARTIAL PANEL ELECTRICAL': { name: 'PARTIAL PANEL ELECTRICAL', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_ENGINE: { + 'PARTIAL PANEL ENGINE': { name: 'PARTIAL PANEL ENGINE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_FUEL_INDICATOR: { + 'PARTIAL PANEL FUEL INDICATOR': { name: 'PARTIAL PANEL FUEL INDICATOR', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Gauge fail flag. */ - PARTIAL_PANEL_HEADING: { + 'PARTIAL PANEL HEADING': { name: 'PARTIAL PANEL HEADING', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_NAV: { + 'PARTIAL PANEL NAV': { name: 'PARTIAL PANEL NAV', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_PITOT: { + 'PARTIAL PANEL PITOT': { name: 'PARTIAL PANEL PITOT', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_TRANSPONDER: { + 'PARTIAL PANEL TRANSPONDER': { name: 'PARTIAL PANEL TRANSPONDER', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_TURN_COORDINATOR: { + 'PARTIAL PANEL TURN COORDINATOR': { name: 'PARTIAL PANEL TURN COORDINATOR', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Gauge fail flag. */ - PARTIAL_PANEL_VACUUM: { + 'PARTIAL PANEL VACUUM': { name: 'PARTIAL PANEL VACUUM', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Gauge fail flag. */ - PARTIAL_PANEL_VERTICAL_VELOCITY: { + 'PARTIAL PANEL VERTICAL VELOCITY': { name: 'PARTIAL PANEL VERTICAL VELOCITY', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** The number of droppable objects at the station number identified by the index. */ - 'DROPPABLE_OBJECTS_COUNT:index': { + 'DROPPABLE OBJECTS COUNT:index': { name: 'DROPPABLE OBJECTS COUNT:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The type of droppable object at the station number identified by the index. */ - 'DROPPABLE_OBJECTS_TYPE:index': { + 'DROPPABLE OBJECTS TYPE:index': { name: 'DROPPABLE OBJECTS TYPE:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: true, }, /** Descriptive name, used in User Interface dialogs, of a droppable object, identified by index. */ - 'DROPPABLE_OBJECTS_UI_NAME:index': { + 'DROPPABLE OBJECTS UI NAME:index': { name: 'DROPPABLE OBJECTS UI NAME:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Number of payload stations (1 to 15). */ - PAYLOAD_STATION_COUNT: { + 'PAYLOAD STATION COUNT': { name: 'PAYLOAD STATION COUNT', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Descriptive name for payload station. */ - 'PAYLOAD_STATION_NAME:index': { + 'PAYLOAD STATION NAME:index': { name: 'PAYLOAD STATION NAME:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** The number of objects at the payload station. */ - 'PAYLOAD_STATION_NUM_SIMOBJECTS:index': { + 'PAYLOAD STATION NUM SIMOBJECTS:index': { name: 'PAYLOAD STATION NUM SIMOBJECTS:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Places the named object at the payload station identified by the index (starting from 1). The string is the Container name (refer to the title property of Simulation Object Configuration Files). */ - 'PAYLOAD_STATION_OBJECT:index': { + 'PAYLOAD STATION OBJECT:index': { name: 'PAYLOAD STATION OBJECT:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Individual payload station weight. */ - 'PAYLOAD_STATION_WEIGHT:index': { + 'PAYLOAD STATION WEIGHT:index': { name: 'PAYLOAD STATION WEIGHT:index', units: 'Pounds', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This is the current state of the fuel warning, either on (true) or off (false). */ - WARNING_FUEL: { + /** This is the current state of the fuel warning, either on (true) or off (false). */ + 'WARNING FUEL': { name: 'WARNING FUEL', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This is the current state of the left fuel tank warning, either on (true) or off (false). */ - WARNING_FUEL_LEFT: { + /** This is the current state of the left fuel tank warning, either on (true) or off (false). */ + 'WARNING FUEL LEFT': { name: 'WARNING FUEL LEFT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This is the current state of the right fuel tank warning, either on (true) or off (false). */ - WARNING_FUEL_RIGHT: { + /** This is the current state of the right fuel tank warning, either on (true) or off (false). */ + 'WARNING FUEL RIGHT': { name: 'WARNING FUEL RIGHT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This is the current state of the low height warning, either on (true) or off (false). */ - WARNING_LOW_HEIGHT: { + /** This is the current state of the low height warning, either on (true) or off (false). */ + 'WARNING LOW HEIGHT': { name: 'WARNING LOW HEIGHT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This is the current state of the oil pressure warning, either on (true) or off (false). */ - WARNING_OIL_PRESSURE: { + /** This is the current state of the oil pressure warning, either on (true) or off (false). */ + 'WARNING OIL PRESSURE': { name: 'WARNING OIL PRESSURE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This is the current state of the vacuum system warning, either on (true) or off (false). */ - WARNING_VACUUM: { + /** This is the current state of the vacuum system warning, either on (true) or off (false). */ + 'WARNING VACUUM': { name: 'WARNING VACUUM', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This is the current state of the left vacuum system warning, either on (true) or off (false). */ - WARNING_VACUUM_LEFT: { + /** This is the current state of the left vacuum system warning, either on (true) or off (false). */ + 'WARNING VACUUM LEFT': { name: 'WARNING VACUUM LEFT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This is the current state of the right vacuum system warning, either on (true) or off (false). */ - WARNING_VACUUM_RIGHT: { + /** This is the current state of the right vacuum system warning, either on (true) or off (false). */ + 'WARNING VACUUM RIGHT': { name: 'WARNING VACUUM RIGHT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This is the current state of the electrical system voltage warning, either on (true) or off (false). */ - WARNING_VOLTAGE: { + /** This is the current state of the electrical system voltage warning, either on (true) or off (false). */ + 'WARNING VOLTAGE': { name: 'WARNING VOLTAGE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Yoke position in horizontal direction. */ - YOKE_X_INIDICATOR: { + 'YOKE X INIDICATOR': { name: 'YOKE X INIDICATOR', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent control deflection left/right (for animation). */ - YOKE_X_POSITION: { + 'YOKE X POSITION': { name: 'YOKE X POSITION', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Percent control deflection left/right (for animation). Also includes AP's inputs. */ - YOKE_X_POSITION_WITH_AP: { + 'YOKE X POSITION WITH AP': { name: 'YOKE X POSITION WITH AP', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Yoke position in vertical direction. */ - YOKE_Y_INIDICATOR: { + 'YOKE Y INIDICATOR': { name: 'YOKE Y INIDICATOR', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent control deflection fore/aft (for animation). */ - YOKE_Y_POSITION: { + 'YOKE Y POSITION': { name: 'YOKE Y POSITION', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Percent control deflection fore/aft (for animation). Also includes AP's inputs. */ - YOKE_Y_POSITION_WITH_AP: { + 'YOKE Y POSITION WITH AP': { name: 'YOKE Y POSITION WITH AP', - units: 'Position', + units: '', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent door/exit open. */ - 'EXIT_OPEN:index': { + 'EXIT OPEN:index': { name: 'EXIT OPEN:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Position of exit relative to datum reference point. */ - 'EXIT_POSX:index': { + 'EXIT POSX:index': { name: 'EXIT POSX:index', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Position of exit relative to datum reference point. */ - 'EXIT_POSY:index': { + 'EXIT POSY:index': { name: 'EXIT POSY:index', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Position of exit relative to datum reference point. */ - 'EXIT_POSZ:index': { + 'EXIT POSZ:index': { name: 'EXIT POSZ:index', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The exit type. */ - 'EXIT_TYPE:index': { + 'EXIT TYPE:index': { name: 'EXIT TYPE:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** The position of the helicopter\'s collective. 0 is fully up, 100 fully depressed. */ - COLLECTIVE_POSITION: { + 'COLLECTIVE POSITION': { name: 'COLLECTIVE POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Rotor bank angle of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'DISK_BANK_ANGLE:index': { + /** +

Rotor bank angle of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'DISK BANK ANGLE:index': { name: 'DISK BANK ANGLE:index', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Rotor bank percent of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'DISK_BANK_PCT:index': { + /** +

Rotor bank percent of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'DISK BANK PCT:index': { name: 'DISK BANK PCT:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Rotor coning percent of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'DISK_CONING_PCT:index': { + /** +

Rotor coning percent of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'DISK CONING PCT:index': { name: 'DISK CONING PCT:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Rotor pitch angle of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'DISK_PITCH_ANGLE:index': { + /** +

Rotor pitch angle of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'DISK PITCH ANGLE:index': { name: 'DISK PITCH ANGLE:index', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Rotor pitch percent of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'DISK_PITCH_PCT:index': { + /** +

Rotor pitch percent of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'DISK PITCH PCT:index': { name: 'DISK PITCH PCT:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Whether the rotor brake is active (1, TRUE) or not (0, FALSE). */ - ROTOR_BRAKE_ACTIVE: { + /** +

Whether the rotor brake is active (1, TRUE) or not (0, FALSE).

+ */ + 'ROTOR BRAKE ACTIVE': { name: 'ROTOR BRAKE ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The percentage actuated of the rotor brake handle. */ - ROTOR_BRAKE_HANDLE_POS: { + /** +

The percentage actuated of the rotor brake handle.

+ */ + 'ROTOR BRAKE HANDLE POS': { name: 'ROTOR BRAKE HANDLE POS', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Whether the rotor chip is detected (1,TRUE) or not (0, FALSE). */ - ROTOR_CHIP_DETECTED: { + /** +

Whether the rotor chip is detected (1,TRUE) or not (0, FALSE).

+ */ + 'ROTOR CHIP DETECTED': { name: 'ROTOR CHIP DETECTED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** Whether the rotor clutch is active (1, TRUE) or not (0, FALSE). */ - ROTOR_CLUTCH_ACTIVE: { + /** +

Whether the rotor clutch is active (1, TRUE) or not (0, FALSE).

+ */ + 'ROTOR CLUTCH ACTIVE': { name: 'ROTOR CLUTCH ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The rotor clutch switch position, either on (1 TRUE) or off (0, FALSE). */ - ROTOR_CLUTCH_SWITCH_POS: { + /** +

The rotor clutch switch position, either on (1 TRUE) or off (0, FALSE).

+ */ + 'ROTOR CLUTCH SWITCH POS': { name: 'ROTOR CLUTCH SWITCH POS', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The rotor collective blade pitch. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - ROTOR_COLLECTIVE_BLADE_PITCH_PCT: { + /** +

The rotor collective blade pitch.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ROTOR COLLECTIVE BLADE PITCH PCT': { name: 'ROTOR COLLECTIVE BLADE PITCH PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The position (angle) at which blade has the maximum cyclic pitch. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - ROTOR_CYCLIC_BLADE_MAX_PITCH_POSITION: { + /** +

The position (angle) at which blade has the maximum cyclic pitch.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ROTOR CYCLIC BLADE MAX PITCH POSITION': { name: 'ROTOR CYCLIC BLADE MAX PITCH POSITION', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The rotor cyclic blade (maximum) pitch. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - ROTOR_CYCLIC_BLADE_PITCH_PCT: { + /** +

The rotor cyclic blade (maximum) pitch.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ROTOR CYCLIC BLADE PITCH PCT': { name: 'ROTOR CYCLIC BLADE PITCH PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Whether the rotor governor is active (1, TRUE) or not (0, FALSE). */ - ROTOR_GOV_ACTIVE: { - name: 'ROTOR GOV ACTIVE', + /** +

Whether the rotor governor is active (1, TRUE) or not (0, FALSE). The SimVar takes an index value, which is the index of the engine to target.

+ */ + 'ROTOR GOV ACTIVE:index': { + name: 'ROTOR GOV ACTIVE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The rotor governor switch position, either on (1 TRUE) or off (0, FALSE). */ - ROTOR_GOV_SWITCH_POS: { - name: 'ROTOR GOV SWITCH POS', + /** +

The rotor governor switch position, either on (1 TRUE) or off (0, FALSE). The SimVar takes an index value, which is the index of the engine to target.

+ */ + 'ROTOR GOV SWITCH POS:index': { + name: 'ROTOR GOV SWITCH POS:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The rotor lateral trim percentage. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - ROTOR_LATERAL_TRIM_PCT: { + /** +

The rotor lateral trim percentage.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ROTOR LATERAL TRIM PCT': { name: 'ROTOR LATERAL TRIM PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The rotor longitudinal trim percentage. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - ROTOR_LONGITUDINAL_TRIM_PCT: { + /** +

The rotor longitudinal trim percentage.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ROTOR LONGITUDINAL TRIM PCT': { name: 'ROTOR LONGITUDINAL TRIM PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Rotor rotation angle of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'ROTOR_ROTATION_ANGLE:index': { + /** +

Rotor rotation angle of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ROTOR ROTATION ANGLE:index': { name: 'ROTOR ROTATION ANGLE:index', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The indexed rotor -RPM. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'ROTOR_RPM:index': { + /** +

The indexed rotor RPM.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ROTOR RPM:index': { name: 'ROTOR RPM:index', units: 'RPM', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent max rated rpm of the given rotor index. Index should be specified to 1 for main rotor and 2 for tail rotor. */ - 'ROTOR_RPM_PCT:index': { + 'ROTOR RPM PCT:index': { name: 'ROTOR RPM PCT:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The main rotor transmission temperature. */ - ROTOR_TEMPERATURE: { + /** +

The main rotor transmission temperature.

+ */ + 'ROTOR TEMPERATURE': { name: 'ROTOR TEMPERATURE', units: 'Rankine', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The position of the indexed rotor. */ - 'STRUCT_ROTOR_POSITION:index': { + 'STRUCT ROTOR POSITION:index': { name: 'STRUCT ROTOR POSITION:index', - units: 'SIMCONNECT_DATA_XYZ', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The pitch position of the tailrotor blades. */ - TAIL_ROTOR_BLADE_PITCH_PCT: { + 'TAIL ROTOR BLADE PITCH PCT': { name: 'TAIL ROTOR BLADE PITCH PCT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Percent tail rotor pedal deflection. */ - TAIL_ROTOR_PEDAL_POSITION: { + 'TAIL ROTOR PEDAL POSITION': { name: 'TAIL ROTOR PEDAL POSITION', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the indexed rotor -RPM. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - 'ENG_ROTOR_RPM:index': { + /** +

Returns the indexed rotor RPM.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'ENG ROTOR RPM:index': { name: 'ENG ROTOR RPM:index', units: 'Percent scalar 16K (Max rpm * 16384)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns the indexed rotor torque. */ - 'ENG_TORQUE_PERCENT:index': { + /** +

Returns the indexed rotor torque.

+ */ + 'ENG TORQUE PERCENT:index': { name: 'ENG TORQUE PERCENT:index', units: 'Percent scalar 16K (Ft/lbs * 16384)', dataType: SimConnectDataType.FLOAT64, @@ -8540,440 +8756,451 @@ Note On SimVars In Multiplayer. */ settable: false, }, /** Set to true if this object is attached to a sling. */ - IS_ATTACHED_TO_SLING: { + 'IS ATTACHED TO SLING': { name: 'IS ATTACHED TO SLING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** The number of sling cables (not hoists) that are configured for the helicopter. */ - NUM_SLING_CABLES: { + /** The number of sling cables (not hoists) that are configured for the helicopter. */ + 'NUM SLING CABLES': { name: 'NUM SLING CABLES', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The payload station (identified by the parameter) where objects will be placed from the sling (identified by the index). */ - 'SLING_ACTIVE_PAYLOAD_STATION:index,_param': { + 'SLING ACTIVE PAYLOAD STATION:index, param': { name: 'SLING ACTIVE PAYLOAD STATION:index, param', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** THis will be True (1) if the indexed cable is broken, or False (0) otherwise. */ - 'SLING_CABLE_BROKEN:index': { + 'SLING CABLE BROKEN:index': { name: 'SLING CABLE BROKEN:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The length of the indexed cable extending from the aircraft. */ - 'SLING_CABLE_EXTENDED_LENGTH:index': { + 'SLING CABLE EXTENDED LENGTH:index': { name: 'SLING CABLE EXTENDED LENGTH:index', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The percentage of the full length of the sling cable deployed. */ - 'SLING_HOIST_PERCENT_DEPLOYED:index': { + 'SLING HOIST PERCENT DEPLOYED:index': { name: 'SLING HOIST PERCENT DEPLOYED:index', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This will be True (1) if the hoist is enabled or False (0) otherwise. */ - 'SLING_HOIST_SWITCH:index': { + 'SLING HOIST SWITCH:index': { name: 'SLING HOIST SWITCH:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** This will be True (1) if the hook is in pickup mode or False (0) otherwise. When True, the hook will be capable of picking up another object. */ - SLING_HOOK_IN_PICKUP_MODE: { + 'SLING HOOK IN PICKUP MODE': { name: 'SLING HOOK IN PICKUP MODE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** If the SimVar units are set as boolean, this will return True (1) if a sling object is attached, or False (0) otherwise. - If the SimVar units are set as a string, tis will return the container title of the object. - Note that there can be multiple sling positions, indexed from 1. The sling positions are set in the Aircraft Configuration File. */ - 'SLING_OBJECT_ATTACHED:index': { + /** +

If the SimVar units are set as boolean, this will return True (1) if a sling object is attached, or False (0) otherwise.

+

If the SimVar units are set as a string, tis will return the container title of the object.

+

Note that there can be multiple sling positions, indexed from 1. The sling positions are set in the Aircraft Configuration File.

+ */ + 'SLING OBJECT ATTACHED:index': { name: 'SLING OBJECT ATTACHED:index', units: 'Bool/String', dataType: SimConnectDataType.INT32, settable: false, }, - /** The electrical load on the indexed engine. */ - 'ENG_ELECTRICAL_LOAD:index': { + /** +

The electrical load on the indexed engine.

+ */ + 'ENG ELECTRICAL LOAD:index': { name: 'ENG ELECTRICAL LOAD:index', units: 'Percent scalar 16K (Max load * 16384)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The fuel pressure for the indexed engine. */ - 'ENG_FUEL_PRESSURE:index': { + /** +

The fuel pressure for the indexed engine.

+ */ + 'ENG FUEL PRESSURE:index': { name: 'ENG FUEL PRESSURE:index', units: 'PSI scalar 16K (Psi * 16384)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The transmission pressure of the indexed engine. */ - 'ENG_TRANSMISSION_PRESSURE:index': { + /** +

The transmission pressure of the indexed engine.

+ */ + 'ENG TRANSMISSION PRESSURE:index': { name: 'ENG TRANSMISSION PRESSURE:index', units: 'PSI scalar 16K (Psi * 16384)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The transmission temperature of the indexed engine. */ - 'ENG_TRANSMISSION_TEMPERATURE:index': { + /** +

The transmission temperature of the indexed engine.

+ */ + 'ENG TRANSMISSION TEMPERATURE:index': { name: 'ENG TRANSMISSION TEMPERATURE:index', units: 'Celsius scalar 16K (Degrees * 16384)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The tubine temperature for the indexed engine. */ - 'ENG_TURBINE_TEMPERATURE:index': { + /** +

The tubine temperature for the indexed engine.

+ */ + 'ENG TURBINE TEMPERATURE:index': { name: 'ENG TURBINE TEMPERATURE:index', units: 'Celsius scalar 16K (degrees * 16384)', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Returns either the pitch (index 0) or the yaw (index 1) of the current gameplay camera. */ - 'CAMERA_GAMEPLAY_PITCH_YAW:index': { + /** Returns either the pitch (index 0) or the yaw (index 1) of the current gameplay camera. */ + 'CAMERA GAMEPLAY PITCH YAW:index': { name: 'CAMERA GAMEPLAY PITCH YAW:index', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** This can be used to have the currently active camera perform a predefined action. Currently only 1 action is supported, but more may be added over time. */ - CAMERA_REQUEST_ACTION: { + 'CAMERA REQUEST ACTION': { name: 'CAMERA REQUEST ACTION', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** This can be used to get or set the camera "state", which will be one of the listed enum values. - Note that not ALL possible enum values are shown, since some values are internal only, and some values will do nothing, but have been reserved for future expansion of the camera system. - Also note that the value "9" is a special case, generally used only when working with in-sim panels and is used to go to the showcase cameras, defaulting to the last selected camera within this section (Drone, Fixed or Environment). */ - CAMERA_STATE: { + /** +

This can be used to get or set the camera "state", which will be one of the listed enum values.

+

Note that not ALL possible enum values are shown, since some values are internal only, and some values will do nothing, but have been reserved for future expansion of the camera system.

+

Also note that the value "9" is a special case, generally used only when working with in-sim panels and is used to go to the showcase cameras, defaulting to the last selected camera within this section (Drone, Fixed or Environment).

+ */ + 'CAMERA STATE': { name: 'CAMERA STATE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** This variable can be used to get or set the camera "sub-state". The options here are generally only required when working with the in-sim panel UI. Note that the "locked" and "unlocked" state will be changed automatically if the following SimVars have their values changed: COCKPIT_CAMERA_HEADLOOK, CHASE_CAMERA_HEADLOOK. */ - CAMERA_SUBSTATE: { + /** This variable can be used to get or set the camera "sub-state". The options here are generally only required when working with the in-sim panel UI. Note that the "locked" and "unlocked" state will be changed automatically if the following SimVars have their values changed: COCKPIT_CAMERA_HEADLOOK, CHASE_CAMERA_HEADLOOK. */ + 'CAMERA SUBSTATE': { name: 'CAMERA SUBSTATE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, - /** With this you can get or set both the type of view for the current camera, as well as the option index, which will be between 0 and the maximum index value (as retrieved using the CAMERA VIEW TYPE AND INDEX MAX SimVar). Supplying an index of 0 to the SimVar will get/set the type (from the selection of enum values listed), and using an index of 1 will get/set the option index, which is an integer value. - - - Please see the Notes On View Types And Indices section below for more information. */ - 'CAMERA_VIEW_TYPE_AND_INDEX:index': { + /** +

With this you can get or set both the type of view for the current camera, as well as the option index, which will be between 0 and the maximum index value (as retrieved using the CAMERA VIEW TYPE AND INDEX MAX SimVar). Supplying an index of 0 to the SimVar will get/set the type (from the selection of enum values listed), and using an index of 1 will get/set the option index, which is an integer value.

+

 

+

Please see the Notes On View Types And Indices section below for more information.

+ */ + 'CAMERA VIEW TYPE AND INDEX:index': { name: 'CAMERA VIEW TYPE AND INDEX:index', - units: 'Enum (index = 0):', - dataType: SimConnectDataType.FLOAT64, + units: '', + dataType: SimConnectDataType.INT32, settable: true, }, - /** This variable can get the number of option indices related to a specific camera view type. The index value supplied to the SimVar should be one of the camera view type Enum values (see CAMERA VIEW TYPE AND INDEX), and the SimVar will return the number of options available for that camera type (counting from 1, so - for example - if the camera view type is "Quickview" and has 8 quickview settings, then CAMERA VIEW TYPE AND INDEX MAX:4 will return 8). Note that this value can be set after a flight has started, but it will have no effect since the number of camera options is initilaised once only and not updated (and the simulation may overwrite the value again even after setting it). - - - Please see the Notes On View Types And Indices section below for more information. */ - 'CAMERA_VIEW_TYPE_AND_INDEX_MAX:index': { + /** +

This variable can get the number of option indices related to a specific camera view type. The index value supplied to the SimVar should be one of the camera view type Enum values (see CAMERA VIEW TYPE AND INDEX), and the SimVar will return the number of options available for that camera type (counting from 1, so - for example - if the camera view type is "Quickview" and has 8 quickview settings, then CAMERA VIEW TYPE AND INDEX MAX:4 will return 8). Note that this value can be set after a flight has started, but it will have no effect since the number of camera options is initilaised once only and not updated (and the simulation may overwrite the value again even after setting it).

+

 

+

Please see the Notes On View Types And Indices section below for more information.

+ */ + 'CAMERA VIEW TYPE AND INDEX MAX:index': { name: 'CAMERA VIEW TYPE AND INDEX MAX:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This gets/sets the focus for the camera zoom, which can be either manual, or auto. The setting affects both the Cockpit and the External (Chase) cameras. - The following SimVars can be used to get/set the level of zoom: COCKPIT_CAMERA_ZOOM or CHASE_CAMERA_ZOOM. */ - GAMEPLAY_CAMERA_FOCUS: { + /** This gets/sets the focus for the camera zoom, which can be either manual, or auto. The setting affects both the Cockpit and the External (Chase) cameras.
+ The following SimVars can be used to get/set the level of zoom: COCKPIT_CAMERA_ZOOM or CHASE_CAMERA_ZOOM. */ + 'GAMEPLAY CAMERA FOCUS': { name: 'GAMEPLAY CAMERA FOCUS', - units: 'Enum:', - dataType: SimConnectDataType.INT32, - settable: true, - }, - /** This SimVar is used to check for a collision along a ray from the center of the user -FOV -and a model node. The available nodes that can be checked using this SimVar must be previously defined in the -[CAMERA_RAY_NODE_COLLISION] -of the cameras.cfg file. The SimVar requires a node -index -value between 1 and 10, corresponding to the node defined in the CFG file, and the SimVar will return 1 (TRUE) if there is a collision along the camera ray or 0 (FALSE) otherwise. You may also supply an index of 0 to perform a collision check for -all -defined nodes, in which case the SimVar will return 1 (TRUE) if there is a collision between the ray and -any -of the defined nodes. Supplying an index outside of the range of 1 to 10, or supplying an index for which no node has been defined, will return 0 (FALSE). */ - IS_CAMERA_RAY_INTERSECT_WITH_NODE: { + units: '', + dataType: SimConnectDataType.INT32, + settable: true, + }, + /** This SimVar is used to check for a collision along a ray from the center of the user FOV and a model node. The available nodes that can be checked using this SimVar must be previously defined in the [CAMERA_RAY_NODE_COLLISION] of the cameras.cfg file. The SimVar requires a node index value between 1 and 10, corresponding to the node defined in the CFG file, and the SimVar will return 1 (TRUE) if there is a collision along the camera ray or 0 (FALSE) otherwise. You may also supply an index of 0 to perform a collision check for all defined nodes, in which case the SimVar will return 1 (TRUE) if there is a collision between the ray and any of the defined nodes. Supplying an index outside of the range of 1 to 10, or supplying an index for which no node has been defined, will return 0 (FALSE).  */ + 'IS CAMERA RAY INTERSECT WITH NODE': { name: 'IS CAMERA RAY INTERSECT WITH NODE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This is used to get/set the look state of the chase (external) camera. Note that this value will also affect the CAMERA_SUBSTATE value, when the CAMERA_STATE is set to 3 (External/Chase). */ - CHASE_CAMERA_HEADLOOK: { + /** This is used to get/set the look state of the chase (external) camera. Note that this value will also affect the CAMERA_SUBSTATE value, when the CAMERA_STATE is set to 3 (External/Chase). */ + 'CHASE CAMERA HEADLOOK': { name: 'CHASE CAMERA HEADLOOK', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Sets/gets the momentum modifier of the chase (external) camera, which is controls how fast/slow the camera will stop moving when no longer being moved by the user. Default is 50%. */ - CHASE_CAMERA_MOMENTUM: { + 'CHASE CAMERA MOMENTUM': { name: 'CHASE CAMERA MOMENTUM', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Sets/gets the translation speed modifier of the chase (external) camara, as a percentage. Default is 50%. */ - CHASE_CAMERA_SPEED: { + 'CHASE CAMERA SPEED': { name: 'CHASE CAMERA SPEED', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Sets/gets the zoom/FOV modifier for the chase (external) camera. Note that when setting this value, it will affect the camera regardless of whether the GAMEPLAY_CAMERA_FOCUS is set to manual or automatic. Default is 50%. */ - CHASE_CAMERA_ZOOM: { + /** Sets/gets the zoom/FOV modifier for the chase (external) camera. Note that when setting this value, it will affect the camera regardless of whether the GAMEPLAY_CAMERA_FOCUS is set to manual or automatic. Default is 50%. */ + 'CHASE CAMERA ZOOM': { name: 'CHASE CAMERA ZOOM', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Sets/gets the speed modifier for when the zoom/FOV chase (external) camera changes zoom/FOV levels. Default is 50%. */ - CHASE_CAMERA_ZOOM_SPEED: { + /** Sets/gets the speed modifier for when the zoom/FOV chase (external) camera changes zoom/FOV levels. Default is 50%. */ + 'CHASE CAMERA ZOOM SPEED': { name: 'CHASE CAMERA ZOOM SPEED', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This can be used to reset the cockpit camera when the CAMERA_STATE is set to 2 (Cockpit). Essentially the same as the user pressing the default reset keys CTRL + Space. */ - CAMERA_ACTION_COCKPIT_VIEW_RESET: { + /** This can be used to reset the cockpit camera when the CAMERA_STATE is set to 2 (Cockpit). Essentially the same as the user pressing the default reset keys CTRL + Space. */ + 'CAMERA ACTION COCKPIT VIEW RESET': { name: 'CAMERA ACTION COCKPIT VIEW RESET', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** This can be used to save a cockpit camera when the CAMERA_STATE is set to 2 (Cockpit). The index value given is the save "slot" that will be used, from 0 to 9. Essentially this is the same as the user pressing the default save keys CTRL + Alt + 0-9. */ - 'CAMERA_ACTION_COCKPIT_VIEW_SAVE:index': { + /** This can be used to save a cockpit camera when the CAMERA_STATE is set to 2 (Cockpit). The index value given is the save "slot" that will be used, from 0 to 9. Essentially this is the same as the user pressing the default save keys CTRL + Alt + 0-9. */ + 'CAMERA ACTION COCKPIT VIEW SAVE:index': { name: 'CAMERA ACTION COCKPIT VIEW SAVE:index', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** This is used to get/set the look state of the cockpit camera. Note that this value will also affect the CAMERA_SUBSTATE value, when the CAMERA_STATE is set to 2 (Cockpit). */ - COCKPIT_CAMERA_HEADLOOK: { + /** This is used to get/set the look state of the cockpit camera. Note that this value will also affect the CAMERA_SUBSTATE value, when the CAMERA_STATE is set to 2 (Cockpit). */ + 'COCKPIT CAMERA HEADLOOK': { name: 'COCKPIT CAMERA HEADLOOK', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** This can be used to get/set the cockpit camera height modifier expressed as a percentage. Default is 50%. */ - COCKPIT_CAMERA_HEIGHT: { + 'COCKPIT CAMERA HEIGHT': { name: 'COCKPIT CAMERA HEIGHT', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This can be used to get or set the autoselect option for the cockpit camera when viewing the instruments (ie: the CAMERA_SUBSTATE is 5). When enabled the camera will move automatically if the player mouse reaches the edge of the screen and there are instrument panels available on that side. */ - COCKPIT_CAMERA_INSTRUMENT_AUTOSELECT: { + /** This can be used to get or set the autoselect option for the cockpit camera when viewing the instruments (ie: the CAMERA_SUBSTATE is 5). When enabled the camera will move automatically if the player mouse reaches the edge of the screen and there are instrument panels available on that side. */ + 'COCKPIT CAMERA INSTRUMENT AUTOSELECT': { name: 'COCKPIT CAMERA INSTRUMENT AUTOSELECT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Sets/gets the momentum modifier of the cockpit camera, which is controls how fast/slow the camera will stop moving when no longer being moved by the user. Default is 50%. */ - COCKPIT_CAMERA_MOMENTUM: { + 'COCKPIT CAMERA MOMENTUM': { name: 'COCKPIT CAMERA MOMENTUM', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Not currently used in the simulation. */ - COCKPIT_CAMERA_SIDE: { + /** Not currently used in the simulation. */ + 'COCKPIT CAMERA SIDE': { name: 'COCKPIT CAMERA SIDE', units: 'Enum', dataType: SimConnectDataType.INT32, settable: false, }, /** Sets/gets the translation speed modifier of the cockpit camara, as a percentage. Default is 50%. */ - COCKPIT_CAMERA_SPEED: { + 'COCKPIT CAMERA SPEED': { name: 'COCKPIT CAMERA SPEED', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Sets/gets the current "upper position" cockpit camera toggle. When 1 (TRUE), the camera is is in the upper position, and when 0 (FALSE) it is in the default position. */ - COCKPIT_CAMERA_UPPER_POSITION: { + 'COCKPIT CAMERA UPPER POSITION': { name: 'COCKPIT CAMERA UPPER POSITION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Sets/gets the zoom/FOV modifier for the cockpit camera. Note that when setting this value, it will affect the camera regardless of whether the GAMEPLAY_CAMERA_FOCUS is set to manual or automatic. Default is 50%. */ - COCKPIT_CAMERA_ZOOM: { + /** Sets/gets the zoom/FOV modifier for the cockpit camera. Note that when setting this value, it will affect the camera regardless of whether the GAMEPLAY_CAMERA_FOCUS is set to manual or automatic. Default is 50%. */ + 'COCKPIT CAMERA ZOOM': { name: 'COCKPIT CAMERA ZOOM', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Sets/gets the speed modifier for when the zoom/FOV cockpit camera changes zoom/FOV levels. Default is 50%. */ - COCKPIT_CAMERA_ZOOM_SPEED: { + /** Sets/gets the speed modifier for when the zoom/FOV cockpit camera changes zoom/FOV levels. Default is 50%. */ + 'COCKPIT CAMERA ZOOM SPEED': { name: 'COCKPIT CAMERA ZOOM SPEED', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Sets/gets the focus modifier for the drone camera. Default is 50%, and a lower value will set the drone focus to things in the foreground and a higher level will set the drone focus to things in the background. Note that this is only taken into account when the DRONE_CAMERA_FOCUS_MODE is set to 3 (manual). */ - DRONE_CAMERA_FOCUS: { + /** Sets/gets the focus modifier for the drone camera. Default is 50%, and a lower value will set the drone focus to things in the foreground and a higher level will set the drone focus to things in the background. Note that this is only taken into account when the DRONE_CAMERA_FOCUS_MODE is set to 3 (manual). */ + 'DRONE CAMERA FOCUS': { name: 'DRONE CAMERA FOCUS', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Sets/gets the current drone focus mode. When set to 3 (manual), the focus position will be based on the DRONE_CAMERA_FOCUS value. */ - DRONE_CAMERA_FOCUS_MODE: { + /** Sets/gets the current drone focus mode. When set to 3 (manual), the focus position will be based on the DRONE_CAMERA_FOCUS value. */ + 'DRONE CAMERA FOCUS MODE': { name: 'DRONE CAMERA FOCUS MODE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** Sets/gets the whether the drone camera is in follow mode or not. */ - DRONE_CAMERA_FOLLOW: { + 'DRONE CAMERA FOLLOW': { name: 'DRONE CAMERA FOLLOW', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Sets/gets the zoom/FOV modifier for the drone camera. Default is 50%. */ - DRONE_CAMERA_FOV: { + /** Sets/gets the zoom/FOV modifier for the drone camera. Default is 50%. */ + 'DRONE CAMERA FOV': { name: 'DRONE CAMERA FOV', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Sets/gets the whether the drone camera is locked or not. */ - DRONE_CAMERA_LOCKED: { + 'DRONE CAMERA LOCKED': { name: 'DRONE CAMERA LOCKED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Sets/gets the rotation speed modifier of the drone camara, as a percentage. Default is 50%. */ - DRONE_CAMERA_SPEED_ROTATION: { + 'DRONE CAMERA SPEED ROTATION': { name: 'DRONE CAMERA SPEED ROTATION', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Sets/gets the translation speed modifier of the drone camara, as a percentage. Default is 50%. */ - DRONE_CAMERA_SPEED_TRAVELLING: { + 'DRONE CAMERA SPEED TRAVELLING': { name: 'DRONE CAMERA SPEED TRAVELLING', units: 'Percentage', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Sets/gets the whether the smart camera is active or not. */ - SMART_CAMERA_ACTIVE: { + 'SMART CAMERA ACTIVE': { name: 'SMART CAMERA ACTIVE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Gets information on the smartcam system. The index sets what kind of information will be returned (or set): - - 0 = Gets the number of smartcam targets in the smart camera list - 1 = Gets or sets the index of the currently selected smartcam target, counting from 0 (so index 0 is the first target in the list). */ - 'SMART_CAMERA_INFO:index': { + /** +

Gets information on the smartcam system. The index sets what kind of information will be returned (or set):

+
    +
  • 0 = Gets the number of smartcam targets in the smart camera list
    • +
  • 1 = Gets or sets the index of the currently selected smartcam target, counting from 0 (so index 0 is the first target in the list).
    • +
+ */ + 'SMART CAMERA INFO:index': { name: 'SMART CAMERA INFO:index', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Retrieves the type of target for the indexed position in the smartcam list, counting from 0 (so index 0 is the first target in the list). */ - 'SMART_CAMERA_LIST:index': { + 'SMART CAMERA LIST:index': { name: 'SMART CAMERA LIST:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** This returns a localized string that represents the smartcam target specified by the given index. Indices count from 0 so index 0 is the first target in the list. */ - 'SMART_CAMERA_LIST_DESCRIPTION:index': { + 'SMART CAMERA LIST DESCRIPTION:index': { name: 'SMART CAMERA LIST DESCRIPTION:index', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, /** Difference of time between the current frame and the last frame where this SimObject has been animated */ - ANIMATION_DELTA_TIME: { + 'ANIMATION DELTA TIME': { name: 'ANIMATION DELTA TIME', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** In case scenery is not loaded for AI planes, this variable can be used to set a default surface elevation. */ - ARTIFICIAL_GROUND_ELEVATION: { + 'ARTIFICIAL GROUND ELEVATION': { name: 'ARTIFICIAL GROUND ELEVATION', units: 'Feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** One of the following: - - "Airplane", - "Helicopter", - "Boat", - "GroundVehicle", - "ControlTower", - "SimpleObject", - "Viewer" */ +
    +
  1. "Airplane",
    2. +
  2. "Helicopter",
    3. +
  3. "Boat",
    4. +
  4. "GroundVehicle",
    5. +
  5. "ControlTower",
    6. +
  6. "SimpleObject",
    7. +
  7. "Viewer"
    8. +
+ */ CATEGORY: { name: 'CATEGORY', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** */ + /**   */ CONTROLLABLE: { name: 'CONTROLLABLE', - units: '', + units: ' ', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Flag value that indicates the cause of a crash. */ - CRASH_FLAG: { + 'CRASH FLAG': { name: 'CRASH FLAG', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** The state of the crash event sequence. */ - CRASH_SEQUENCE: { + 'CRASH SEQUENCE': { name: 'CRASH SEQUENCE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Altitude of surface. */ - GROUND_ALTITUDE: { + 'GROUND ALTITUDE': { name: 'GROUND ALTITUDE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** What frame of the hand is currently used. */ - HAND_ANIM_STATE: { + 'HAND ANIM STATE': { name: 'HAND ANIM STATE', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** The ID of the idle animation for the sim object. */ - IDLE_ANIMATION_ID: { + 'IDLE ANIMATION ID': { name: 'IDLE ANIMATION ID', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, @@ -8984,15 +9211,15 @@ of the defined nodes. Supplying an index outside of the range of 1 to 10, or sup dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** */ - MISSION_SCORE: { + /**   */ + 'MISSION SCORE': { name: 'MISSION SCORE', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This will be TRUE if the parachute has opened and FALSE otherwise. Currently this is only applied to the Parachute SimObject used by Winches. */ - PARACHUTE_OPEN: { + /** This will be TRUE if the parachute has opened and FALSE otherwise. Currently this is only applied to the Parachute SimObject used by Winches. */ + 'PARACHUTE OPEN': { name: 'PARACHUTE OPEN', units: 'Bool', dataType: SimConnectDataType.INT32, @@ -9006,862 +9233,869 @@ of the defined nodes. Supplying an index outside of the range of 1 to 10, or sup settable: true, }, /** True indicates crash detection is turned on. */ - REALISM_CRASH_DETECTION: { + 'REALISM CRASH DETECTION': { name: 'REALISM CRASH DETECTION', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** True indicates crashing with other aircraft is possible. */ - REALISM_CRASH_WITH_OTHERS: { + 'REALISM CRASH WITH OTHERS': { name: 'REALISM CRASH WITH OTHERS', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Is sim disabled. */ - SIM_DISABLED: { + 'SIM DISABLED': { name: 'SIM DISABLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** On ground flag. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - SIM_ON_GROUND: { + /** +

On ground flag.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'SIM ON GROUND': { name: 'SIM ON GROUND', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** */ - SIM_SHOULD_SET_ON_GROUND: { + /**   */ + 'SIM SHOULD SET ON GROUND': { name: 'SIM SHOULD SET ON GROUND', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, - /** Returns true if Track IR is enabled or not. */ - TRACK_IR_ENABLE: { + /** Returns true if Track IR is enabled or not. */ + 'TRACK IR ENABLE': { name: 'TRACK IR ENABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Speed relative to the earths center. */ - TOTAL_WORLD_VELOCITY: { + 'TOTAL WORLD VELOCITY': { name: 'TOTAL WORLD VELOCITY', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Is input allowed from the user. */ - USER_INPUT_ENABLED: { + 'USER INPUT ENABLED': { name: 'USER INPUT ENABLED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** Model radius. */ - VISUAL_MODEL_RADIUS: { + 'VISUAL MODEL RADIUS': { name: 'VISUAL MODEL RADIUS', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Speed relative to earth, in East/West direction. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - VELOCITY_WORLD_X: { + /** +

Speed relative to earth, in East/West direction.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'VELOCITY WORLD X': { name: 'VELOCITY WORLD X', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Speed relative to earth, in vertical direction. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - VELOCITY_WORLD_Y: { + /** +

Speed relative to earth, in vertical direction.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'VELOCITY WORLD Y': { name: 'VELOCITY WORLD Y', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Speed relative to earth, in North/South direction. - NOTE: This is available in multiplayer -to all far aircraft. See here for more information: -Note On SimVars In Multiplayer. */ - VELOCITY_WORLD_Z: { + /** +

Speed relative to earth, in North/South direction.

+

NOTE: This is available in multiplayer to all far aircraft. See here for more information: Note On SimVars In Multiplayer.

+ */ + 'VELOCITY WORLD Z': { name: 'VELOCITY WORLD Z', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Ambient density. */ - AMBIENT_DENSITY: { + 'AMBIENT DENSITY': { name: 'AMBIENT DENSITY', units: 'Slugs per cubic feet', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The current precipitation rate. */ - AMBIENT_PRECIP_RATE: { + 'AMBIENT PRECIP RATE': { name: 'AMBIENT PRECIP RATE', units: 'millimeters of water', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The current state of precipitation. */ - AMBIENT_PRECIP_STATE: { + 'AMBIENT PRECIP STATE': { name: 'AMBIENT PRECIP STATE', - units: 'Mask:', + units: '', dataType: SimConnectDataType.INT32, settable: false, }, /** Ambient pressure. */ - AMBIENT_PRESSURE: { + 'AMBIENT PRESSURE': { name: 'AMBIENT PRESSURE', units: 'Inches of mercury, inHg', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Ambient temperature. */ - AMBIENT_TEMPERATURE: { + 'AMBIENT TEMPERATURE': { name: 'AMBIENT TEMPERATURE', units: 'Celsius', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Ambient visibility (only measures ambient particle visibility - related to ambient density). */ - AMBIENT_VISIBILITY: { + 'AMBIENT VISIBILITY': { name: 'AMBIENT VISIBILITY', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Wind direction, relative to true north. */ - AMBIENT_WIND_DIRECTION: { + 'AMBIENT WIND DIRECTION': { name: 'AMBIENT WIND DIRECTION', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Wind velocity. */ - AMBIENT_WIND_VELOCITY: { + 'AMBIENT WIND VELOCITY': { name: 'AMBIENT WIND VELOCITY', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Wind component in East/West direction. */ - AMBIENT_WIND_X: { + 'AMBIENT WIND X': { name: 'AMBIENT WIND X', units: 'Meters per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Wind component in vertical direction. */ - AMBIENT_WIND_Y: { + 'AMBIENT WIND Y': { name: 'AMBIENT WIND Y', units: 'Meters per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Wind component in North/South direction. */ - AMBIENT_WIND_Z: { + 'AMBIENT WIND Z': { name: 'AMBIENT WIND Z', units: 'Meters per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Barometric pressure. */ - BAROMETER_PRESSURE: { + 'BAROMETER PRESSURE': { name: 'BAROMETER PRESSURE', units: 'Millibars', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The density altitude is the altitude relative to standard atmospheric conditions at which the air density would be equal to the indicated air density at the place of observation. The calculation is as follows: - density_altitude = pressure_altitude + 118.8 * (outside_air_temp -- ISA_temp) */ - DENSITY_ALTITUDE: { + /** +

The density altitude is the altitude relative to standard atmospheric conditions at which the air density would be equal to the indicated air density at the place of observation. The calculation is as follows:

+

density_altitude = pressure_altitude + 118.8 * (outside_air_temp - ISA_temp)

+ */ + 'DENSITY ALTITUDE': { name: 'DENSITY ALTITUDE', units: 'ft', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Barometric pressure at sea level. */ - SEA_LEVEL_PRESSURE: { + 'SEA LEVEL PRESSURE': { name: 'SEA LEVEL PRESSURE', units: 'Millibars', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** X (latitude), Y (vertical) and Z (longitude) components of the wind. */ - STRUCT_AMBIENT_WIND: { + 'STRUCT AMBIENT WIND': { name: 'STRUCT AMBIENT WIND', units: 'Feet per second', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The desired speed of the AI object. */ - AI_DESIRED_SPEED: { + 'AI DESIRED SPEED': { name: 'AI DESIRED SPEED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** A list of waypoints that an AI controlled object should follow. */ - AI_WAYPOINT_LIST: { + 'AI WAYPOINT LIST': { name: 'AI WAYPOINT LIST', units: 'SIMCONNECT_DATA_WAYPOINT', - dataType: SimConnectDataType.WAYPOINT, + dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The current waypoint in the list. */ - AI_CURRENT_WAYPOINT: { + 'AI CURRENT WAYPOINT': { name: 'AI CURRENT WAYPOINT', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The desired heading of the AI object. */ - AI_DESIRED_HEADING: { + 'AI DESIRED HEADING': { name: 'AI DESIRED HEADING', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The time required by the AI aircraft to make a 90º turn. */ - AI_GROUNDTURNTIME: { + 'AI GROUNDTURNTIME': { name: 'AI GROUNDTURNTIME', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The ground cruising speed for the AI aircraft. */ - AI_GROUNDCRUISESPEED: { + 'AI GROUNDCRUISESPEED': { name: 'AI GROUNDCRUISESPEED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The ground turning speed for the AI aircraft. */ - AI_GROUNDTURNSPEED: { + 'AI GROUNDTURNSPEED': { name: 'AI GROUNDTURNSPEED', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This can be used to request whether the AI aircraft is IFR or VFR. Note that if an aircraft does not have a flight plan, the value returned will be 0 (or false). */ - AI_TRAFFIC_ISIFR: { + /** This can be used to request whether the AI aircraft is IFR or VFR. Note that if an aircraft does not have a flight plan, the value returned will be 0 (or false).  */ + 'AI TRAFFIC ISIFR': { name: 'AI TRAFFIC ISIFR', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, - /** This will return a string describing an AI aircraft state. If the aircraft is under ATC control the string will be one of the following: - - "init" - "sleep" - "flt plan" - "startup" - "preflight support" - "clearance" - "push back 1" - "push back 2" - "pre taxi out" - "taxi out" - "takeoff 1" - "takeoff 2" - "T&G depart" - "enroute" - "pattern" - "landing" - "rollout" - "go around" - "taxi in" - "shutdown" - "postflight support" - - - - - If the aircraft is not under ATC control, the string will be one of these: - - "Sleep" - "Waypoint" - "Takeoff" - "Landing" - "Taxi" - - - - Note that if an aircraft does not have a flight plan, the value returned will be an empty string "". */ - AI_TRAFFIC_STATE: { + /** +

This will return a string describing an AI aircraft state. If the aircraft is under ATC control the string will be one of the following:

+
    +
  1. "init"
    2. +
  2. "sleep"
    3. +
  3. "flt plan"
    4. +
  4. "startup"
    5. +
  5. "preflight support"
    6. +
  6. "clearance"
    7. +
  7. "push back 1"
    8. +
  8. "push back 2"
    9. +
  9. "pre taxi out"
    10. +
  10. "taxi out"
    11. +
  11. "takeoff 1"
    12. +
  12. "takeoff 2"
    13. +
  13. "T&G depart"
    14. +
  14. "enroute"
    15. +
  15. "pattern"
    16. +
  16. "landing"
    17. +
  17. "rollout"
    18. +
  18. "go around"
    19. +
  19. "taxi in"
    20. +
  20. "shutdown"
    21. +
  21. "postflight support" 
    22. +
+

 

+

If the aircraft is not under ATC control, the string will be one of these:

+
    +
  1. "Sleep"
    2. +
  2. "Waypoint"
    3. +
  3. "Takeoff"
    4. +
  4. "Landing"
    5. +
  5. "Taxi"
    6. +
+

 

+

Note that if an aircraft does not have a flight plan, the value returned will be an empty string "".

+ */ + 'AI TRAFFIC STATE': { name: 'AI TRAFFIC STATE', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** The ICAO code of the current airport. -If an aircraft does not have a flight plan, the value returned will be an empty string "". */ - AI_TRAFFIC_CURRENT_AIRPORT: { + /** The ICAO code of the current airport. If an aircraft does not have a flight plan, the value returned will be an empty string "". */ + 'AI TRAFFIC CURRENT AIRPORT': { name: 'AI TRAFFIC CURRENT AIRPORT', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** The assigned runway name (for example: "32R"). -If an aircraft does not have a flight plan, the value returned will be an empty string "". */ - AI_TRAFFIC_ASSIGNED_RUNWAY: { + /** The assigned runway name (for example: "32R"). If an aircraft does not have a flight plan, the value returned will be an empty string "". */ + 'AI TRAFFIC ASSIGNED RUNWAY': { name: 'AI TRAFFIC ASSIGNED RUNWAY', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** The assigned parking name. The string will take the form: - Name + Number, Type ( radius ) - For example: - - "Ramp 1, RAMP sml (10m)" - "Gate G 4, RAMP lrg (18m)" - - If an aircraft does not have a flight plan, the value returned will be an empty string "". */ - AI_TRAFFIC_ASSIGNED_PARKING: { + /** +

The assigned parking name. The string will take the form:

+ 
Name + Number, Type ( radius )
+

For example:

+
    +
  • "Ramp 1, RAMP sml (10m)"
    • +
  • "Gate G 4, RAMP lrg (18m)"
    • +
+

If an aircraft does not have a flight plan, the value returned will be an empty string "".

+ */ + 'AI TRAFFIC ASSIGNED PARKING': { name: 'AI TRAFFIC ASSIGNED PARKING', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** The ICAO code of the departure airport in the current schedule. + /** +

The ICAO code of the departure airport in the current schedule. 

+

This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will an empty string"".

+ */ + 'AI TRAFFIC FROMAIRPORT': { name: 'AI TRAFFIC FROMAIRPORT', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** The ICAO code of the destination airport in the current schedule. - - This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will an empty string"". */ - AI_TRAFFIC_TOAIRPORT: { + /** +

The ICAO code of the destination airport in the current schedule. 

+

This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will an empty string"".

+ */ + 'AI TRAFFIC TOAIRPORT': { name: 'AI TRAFFIC TOAIRPORT', - units: 'String', + units: '', dataType: SimConnectDataType.STRINGV, settable: false, }, - /** The estimated time of departure for the current schedule entry, given as the number of seconds difference from the current simulation time. This can be negative if ETD is earlier than the current simulation time - This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will be 0. */ - AI_TRAFFIC_ETD: { + /** +

The estimated time of departure for the current schedule entry, given as the number of seconds difference from the current simulation time. This can be negative if ETD is earlier than the current simulation time

+

This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will be 0.

+ */ + 'AI TRAFFIC ETD': { name: 'AI TRAFFIC ETD', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Estimated time of arrival for the current schedule entry, given as the number of seconds difference from the current simulated time. This can be negative if ETA is earlier than the current simulated time. - This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will be 0. */ - AI_TRAFFIC_ETA: { + /** +

Estimated time of arrival for the current schedule entry, given as the number of seconds difference from the current simulated time. This can be negative if ETA is earlier than the current simulated time.

+

This variable is only valid for aircraft generated by the traffic database that have schedules. If an aircraft does not have a schedule, the value returned will be 0.

+ */ + 'AI TRAFFIC ETA': { name: 'AI TRAFFIC ETA', units: 'Seconds', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Deprecated, do not use! */ - STRUCT_DAMAGEVISIBLE: { + /** Deprecated, do not use! */ + 'STRUCT DAMAGEVISIBLE': { name: 'STRUCT DAMAGEVISIBLE', units: '-', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Returns a pitch, bank and heading value (for what will depend on the SimVar being used). */ - STRUCT_PBH32: { + 'STRUCT PBH32': { name: 'STRUCT PBH32', - units: 'SIMCONNECT_DATA_XYZ', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Not currently used in the simulation. */ - STRUCT_REALISM_VARS: { + /** Not currently used in the simulation. */ + 'STRUCT REALISM VARS': { name: 'STRUCT REALISM VARS', units: '-', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The relative surface velocity. */ - STRUCT_SURFACE_RELATIVE_VELOCITY: { + 'STRUCT SURFACE RELATIVE VELOCITY': { name: 'STRUCT SURFACE RELATIVE VELOCITY', - units: 'SIMCONNECT_DATA_XYZ structure, feet per second', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The world velocity. */ - STRUCT_WORLDVELOCITY: { + 'STRUCT WORLDVELOCITY': { name: 'STRUCT WORLDVELOCITY', - units: 'SIMCONNECT_DATA_XYZ structure, feet per second', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The world acceleration for each axis. Individual world acceleration values are in the Aircraft Position and Speed section. */ - STRUCT_WORLD_ACCELERATION: { + 'STRUCT WORLD ACCELERATION': { name: 'STRUCT WORLD ACCELERATION', - units: 'SIMCONNECT_DATA_XYZ structure, feet per second squared', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The world rotation velocity. */ - STRUCT_WORLD_ROTATION_VELOCITY: { + 'STRUCT WORLD ROTATION VELOCITY': { name: 'STRUCT WORLD ROTATION VELOCITY', - units: 'SIMCONNECT_DATA_XYZ structure, radians per second', - dataType: SimConnectDataType.XYZ, + units: '', + dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The amount of bomb ammunition available. */ - BOMB_AMMO: { + 'BOMB AMMO': { name: 'BOMB AMMO', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The amount of cannon ammunition available. */ - CANNON_AMMO: { + 'CANNON AMMO': { name: 'CANNON AMMO', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The amount of gun ammunition available. */ - GUN_AMMO: { + 'GUN AMMO': { name: 'GUN AMMO', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The amount of rocket ammunition available. */ - ROCKET_AMMO: { + 'ROCKET AMMO': { name: 'ROCKET AMMO', units: 'Number', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Current angle of the baggage loader ramp, relative to the ground. */ - BAGGAGELOADER_ANGLE_CURRENT: { + 'BAGGAGELOADER ANGLE CURRENT': { name: 'BAGGAGELOADER ANGLE CURRENT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Target angle of the baggage loader ramp, relative to the ground. */ - BAGGAGELOADER_ANGLE_TARGET: { + 'BAGGAGELOADER ANGLE TARGET': { name: 'BAGGAGELOADER ANGLE TARGET', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** "Y" axis position of the end of the baggage loader ramp, relative to the ground. */ - BAGGAGELOADER_END_RAMP_Y: { + 'BAGGAGELOADER END RAMP Y': { name: 'BAGGAGELOADER END RAMP Y', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** "Z" axis position of the end of the baggage loader ramp, relative to the ground. */ - BAGGAGELOADER_END_RAMP_Z: { + 'BAGGAGELOADER END RAMP Z': { name: 'BAGGAGELOADER END RAMP Z', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** "Y" axis position of the baggage loader ramp pivot, relative to the ground. */ - BAGGAGELOADER_PIVOT_Y: { + 'BAGGAGELOADER PIVOT Y': { name: 'BAGGAGELOADER PIVOT Y', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** "Z" axis position of the baggage loader ramp pivot, relative to the ground. */ - BAGGAGELOADER_PIVOT_Z: { + 'BAGGAGELOADER PIVOT Z': { name: 'BAGGAGELOADER PIVOT Z', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The current altitude -AGL of the top of the boarding ramp stairs. */ - BOARDINGRAMP_ELEVATION_CURRENT: { + /** The current altitude AGL of the top of the boarding ramp stairs. */ + 'BOARDINGRAMP ELEVATION CURRENT': { name: 'BOARDINGRAMP ELEVATION CURRENT', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The target altitude AGL of the top of the boarding ramp stairs. */ - BOARDINGRAMP_ELEVATION_TARGET: { + /** The target altitude AGL of the top of the boarding ramp stairs. */ + 'BOARDINGRAMP ELEVATION TARGET': { name: 'BOARDINGRAMP ELEVATION TARGET', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The "Y" axis position of the top of the boarding ramp stairs when extended at maximal capacity, relative to the ground. */ - BOARDINGRAMP_END_POSITION_Y: { + 'BOARDINGRAMP END POSITION Y': { name: 'BOARDINGRAMP END POSITION Y', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The "Z" axis position of the top of the boarding ramp stairs when extended at maximal capacity, relative to the ground. */ - BOARDINGRAMP_END_POSITION_Z: { + 'BOARDINGRAMP END POSITION Z': { name: 'BOARDINGRAMP END POSITION Z', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The current orientation of the boarding ramp stairs, where 0 is at rest and 1 is suited for boarding. */ - BOARDINGRAMP_ORIENTATION_CURRENT: { + 'BOARDINGRAMP ORIENTATION CURRENT': { name: 'BOARDINGRAMP ORIENTATION CURRENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The target orientation of of the boarding ramp stairs, where 0 is at rest and 1 is suited for boarding. */ - BOARDINGRAMP_ORIENTATION_TARGET: { + 'BOARDINGRAMP ORIENTATION TARGET': { name: 'BOARDINGRAMP ORIENTATION TARGET', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The "Y" axis -position of the top of the boarding ramp stairs when at minimal extension, relative to the ground. */ - BOARDINGRAMP_START_POSITION_Y: { + /** The "Y" axis position of the top of the boarding ramp stairs when at minimal extension, relative to the ground. */ + 'BOARDINGRAMP START POSITION Y': { name: 'BOARDINGRAMP START POSITION Y', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The "Z" axis -position of the top of the boarding ramp stairs when at minimal extension, relative to the ground. */ - BOARDINGRAMP_START_POSITION_Z: { + /** The "Z" axis position of the top of the boarding ramp stairs when at minimal extension, relative to the ground. */ + 'BOARDINGRAMP START POSITION Z': { name: 'BOARDINGRAMP START POSITION Z', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The "Z" axis position of the point of contact between the catering truck and the bottom of the aircraft door, relative to the ground. */ - CATERINGTRUCK_AIRCRAFT_DOOR_CONTACT_OFFSET_Z: { + 'CATERINGTRUCK AIRCRAFT DOOR CONTACT OFFSET Z': { name: 'CATERINGTRUCK AIRCRAFT DOOR CONTACT OFFSET Z', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The current altitude AGL of the bottom of the catering truck container. */ - CATERINGTRUCK_ELEVATION_CURRENT: { + /** The current altitude AGL of the bottom of the catering truck container. */ + 'CATERINGTRUCK ELEVATION CURRENT': { name: 'CATERINGTRUCK ELEVATION CURRENT', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** The target altitude AGL of the bottom of the catering truck container. */ - CATERINGTRUCK_ELEVATION_TARGET: { + /** The target altitude AGL of the bottom of the catering truck container. */ + 'CATERINGTRUCK ELEVATION TARGET': { name: 'CATERINGTRUCK ELEVATION TARGET', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The current state of the catering truck when opening the container and deploying the bridge, where 0 is fully closed and 1 is fully opened and deployed. */ - CATERINGTRUCK_OPENING_CURRENT: { + 'CATERINGTRUCK OPENING CURRENT': { name: 'CATERINGTRUCK OPENING CURRENT', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The target state of the catering truck the container is opene and the bridge deployed, where 0 is fully closed and 1 is fully opened and deployed. */ - CATERINGTRUCK_OPENING_TARGET: { + 'CATERINGTRUCK OPENING TARGET': { name: 'CATERINGTRUCK OPENING TARGET', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The current deployment amount of the fuel truck hose. Currently can only be set to 0 (not deployed) and 1 (deployed). */ - FUELTRUCK_HOSE_DEPLOYED: { + 'FUELTRUCK HOSE DEPLOYED': { name: 'FUELTRUCK HOSE DEPLOYED', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The "X" axis position of the end of the fuel truck hose when fully deployed, relative to the ground. */ - FUELTRUCK_HOSE_END_POSX: { + 'FUELTRUCK HOSE END POSX': { name: 'FUELTRUCK HOSE END POSX', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The "Z" axis position of the end of the fuel truck hose when fully deployed, relative to the ground. */ - FUELTRUCK_HOSE_END_POSZ: { + 'FUELTRUCK HOSE END POSZ': { name: 'FUELTRUCK HOSE END POSZ', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The heading of the end of the fuel truck hose, relative to the vehicle heading. */ - FUELTRUCK_HOSE_END_RELATIVE_HEADING: { + 'FUELTRUCK HOSE END RELATIVE HEADING': { name: 'FUELTRUCK HOSE END RELATIVE HEADING', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The current deployment amount of the ground power unit hose. Currently can only be set to 0 (not deployed) and 1 (deployed). */ - GROUNDPOWERUNIT_HOSE_DEPLOYED: { + 'GROUNDPOWERUNIT HOSE DEPLOYED': { name: 'GROUNDPOWERUNIT HOSE DEPLOYED', units: 'Percent Over 100', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The "X" axis position of the end of the ground power unit hose when fully deployed, relative to the ground. */ - GROUNDPOWERUNIT_HOSE_END_POSX: { + 'GROUNDPOWERUNIT HOSE END POSX': { name: 'GROUNDPOWERUNIT HOSE END POSX', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The "Z" axis position of the end of the ground power unit hose when fully deployed, relative to the ground. */ - GROUNDPOWERUNIT_HOSE_END_POSZ: { + 'GROUNDPOWERUNIT HOSE END POSZ': { name: 'GROUNDPOWERUNIT HOSE END POSZ', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The heading of the end of the ground power unit hose, relative to the vehicle heading. */ - GROUNDPOWERUNIT_HOSE_END_RELATIVE_HEADING: { + 'GROUNDPOWERUNIT HOSE END RELATIVE HEADING': { name: 'GROUNDPOWERUNIT HOSE END RELATIVE HEADING', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The target position for the left bend animation of the jetway hood. */ - JETWAY_HOOD_LEFT_BEND: { + 'JETWAY HOOD LEFT BEND': { name: 'JETWAY HOOD LEFT BEND', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The target angle for the left deployment animation of the jetway hood, where 0 is considered vertical. */ - JETWAY_HOOD_LEFT_DEPLOYMENT: { + 'JETWAY HOOD LEFT DEPLOYMENT': { name: 'JETWAY HOOD LEFT DEPLOYMENT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The target position for the right bend animation of the jetway hood. */ - JETWAY_HOOD_RIGHT_BEND: { + 'JETWAY HOOD RIGHT BEND': { name: 'JETWAY HOOD RIGHT BEND', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The target angle for the right deployment animation of the jetway hood, where 0 is considered vertical. */ - JETWAY_HOOD_RIGHT_DEPLOYMENT: { + 'JETWAY HOOD RIGHT DEPLOYMENT': { name: 'JETWAY HOOD RIGHT DEPLOYMENT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Target position for the top horizontal animation of the jetway hood. Values can be between -100% and 100%. */ - JETWAY_HOOD_TOP_HORIZONTAL: { + 'JETWAY HOOD TOP HORIZONTAL': { name: 'JETWAY HOOD TOP HORIZONTAL', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** Target position for the top vertical animation of the jetway hood. Values can be between -100% and 100%. */ - JETWAY_HOOD_TOP_VERTICAL: { + 'JETWAY HOOD TOP VERTICAL': { name: 'JETWAY HOOD TOP VERTICAL', units: 'Percent', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** This will be 1 (TRUE) id the jetway -body -is currently moving (it will not include checks on hood animation). */ - JETWAY_MOVING: { + /** This will be 1 (TRUE) id the jetway body is currently moving (it will not include checks on hood animation). */ + 'JETWAY MOVING': { name: 'JETWAY MOVING', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** The current angle of the jetway wheels. */ - JETWAY_WHEEL_ORIENTATION_CURRENT: { + 'JETWAY WHEEL ORIENTATION CURRENT': { name: 'JETWAY WHEEL ORIENTATION CURRENT', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The (approximate) target angle for the jetway wheels. */ - JETWAY_WHEEL_ORIENTATION_TARGET: { + 'JETWAY WHEEL ORIENTATION TARGET': { name: 'JETWAY WHEEL ORIENTATION TARGET', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The current speed of the jetway wheels. */ - JETWAY_WHEEL_SPEED: { + 'JETWAY WHEEL SPEED': { name: 'JETWAY WHEEL SPEED', units: 'Meters per second', dataType: SimConnectDataType.FLOAT64, settable: true, }, - /** Currently not used in the simulation. */ - MARSHALLER_AIRCRAFT_DIRECTION_PARKINGSPACE: { + /** Currently not used in the simulation. */ + 'MARSHALLER AIRCRAFT DIRECTION PARKINGSPACE': { name: 'MARSHALLER AIRCRAFT DIRECTION PARKINGSPACE', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** The distance between the Marshaller and the aircraft. */ - MARSHALLER_AIRCRAFT_DISTANCE: { + /** The distance between the Marshaller and the aircraft. */ + 'MARSHALLER AIRCRAFT DISTANCE': { name: 'MARSHALLER AIRCRAFT DISTANCE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Position on the X axis of the aircraft in the parking space (negative means the aircraft is on the left side and positive the right side). */ - MARSHALLER_AIRCRAFT_DISTANCE_DIRECTION_X_PARKINGSPACE: { + 'MARSHALLER AIRCRAFT DISTANCE DIRECTION X PARKINGSPACE': { name: 'MARSHALLER AIRCRAFT DISTANCE DIRECTION X PARKINGSPACE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Position on the Z axis of the aircraft in the parking space (negative means the aircraft is behind the parking space and positive is in front of the parking space). */ - MARSHALLER_AIRCRAFT_DISTANCE_DIRECTION_Z_PARKINGSPACE: { + 'MARSHALLER AIRCRAFT DISTANCE DIRECTION Z PARKINGSPACE': { name: 'MARSHALLER AIRCRAFT DISTANCE DIRECTION Z PARKINGSPACE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if the engine(s) of the aircraft is (are) shut down. */ - MARSHALLER_AIRCRAFT_ENGINE_SHUTDOWN: { + 'MARSHALLER AIRCRAFT ENGINE SHUTDOWN': { name: 'MARSHALLER AIRCRAFT ENGINE SHUTDOWN', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** Angle between the direction of the aircraft and the direction of the parking place. */ - MARSHALLER_AIRCRAFT_HEADING_PARKINGSPACE: { + 'MARSHALLER AIRCRAFT HEADING PARKINGSPACE': { name: 'MARSHALLER AIRCRAFT HEADING PARKINGSPACE', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: false, }, - /** Value in Z axis of the projection from the aircraft position following the heading of the aircraft. */ - MARSHALLER_AIRCRAFT_PROJECTION_POINT_PARKINGSPACE: { + /** +

Value in Z axis of the projection from the aircraft position following the heading of the aircraft.

+ */ + 'MARSHALLER AIRCRAFT PROJECTION POINT PARKINGSPACE': { name: 'MARSHALLER AIRCRAFT PROJECTION POINT PARKINGSPACE', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The velocity of the aircraft. */ - MARSHALLER_AIRCRAFT_VELOCITY: { + 'MARSHALLER AIRCRAFT VELOCITY': { name: 'MARSHALLER AIRCRAFT VELOCITY', units: 'Knots', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Pushback angle (the heading of the tug). */ - PUSHBACK_ANGLE: { + 'PUSHBACK ANGLE': { name: 'PUSHBACK ANGLE', units: 'Radians', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** True if this vehicle is attached to an aircraft. */ - PUSHBACK_ATTACHED: { + 'PUSHBACK ATTACHED': { name: 'PUSHBACK ATTACHED', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** True if a push back is available on the parking space. */ - PUSHBACK_AVAILABLE: { + 'PUSHBACK AVAILABLE': { name: 'PUSHBACK AVAILABLE', units: 'Bool', dataType: SimConnectDataType.INT32, settable: true, }, /** The towpoint position, relative to the aircrafts datum reference point. */ - PUSHBACK_CONTACTX: { + 'PUSHBACK CONTACTX': { name: 'PUSHBACK CONTACTX', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Pushback contact position in vertical direction. */ - PUSHBACK_CONTACTY: { + 'PUSHBACK CONTACTY': { name: 'PUSHBACK CONTACTY', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Pushback contact position in fore/aft direction. */ - PUSHBACK_CONTACTZ: { + 'PUSHBACK CONTACTZ': { name: 'PUSHBACK CONTACTZ', units: 'Feet (ft)', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** Type of pushback. */ - 'PUSHBACK_STATE:index': { + 'PUSHBACK STATE:index': { name: 'PUSHBACK STATE:index', - units: 'Enum:', + units: '', dataType: SimConnectDataType.INT32, settable: true, }, /** True if waiting for pushback. */ - PUSHBACK_WAIT: { + 'PUSHBACK WAIT': { name: 'PUSHBACK WAIT', units: 'Bool', dataType: SimConnectDataType.INT32, settable: false, }, /** The length of the link at the back of the vehicle used to attach a wagon behind. */ - WAGON_BACK_LINK_LENGTH: { + 'WAGON BACK LINK LENGTH': { name: 'WAGON BACK LINK LENGTH', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The current orientation of the link at the back of the vehicle used to attach a wagon behind. */ - WAGON_BACK_LINK_ORIENTATION: { + 'WAGON BACK LINK ORIENTATION': { name: 'WAGON BACK LINK ORIENTATION', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The "Z" axis position of the start of the link at the back of the vehicle used to attach a wagon behind, relative to the ground. */ - WAGON_BACK_LINK_START_POSZ: { + 'WAGON BACK LINK START POSZ': { name: 'WAGON BACK LINK START POSZ', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The length of the link at the front of the vehicle used to be attached as wagon. */ - WAGON_FRONT_LINK_LENGTH: { + 'WAGON FRONT LINK LENGTH': { name: 'WAGON FRONT LINK LENGTH', units: 'Meters', dataType: SimConnectDataType.FLOAT64, settable: false, }, /** The current orientation of the link at the front of the vehicle used to be attached as wagon. */ - WAGON_FRONT_LINK_ORIENTATION: { + 'WAGON FRONT LINK ORIENTATION': { name: 'WAGON FRONT LINK ORIENTATION', units: 'Degrees', dataType: SimConnectDataType.FLOAT64, settable: true, }, /** The "Z" axis position of the start of the link at the front of the vehicle used to be attached as wagon, relative to the ground. */ - WAGON_FRONT_LINK_START_POSZ: { + 'WAGON FRONT LINK START POSZ': { name: 'WAGON FRONT LINK START POSZ', units: 'Meters', dataType: SimConnectDataType.FLOAT64, diff --git a/package.json b/package.json index 8061880..207f882 100644 --- a/package.json +++ b/package.json @@ -41,7 +41,6 @@ "@types/jest": "^29.2.4", "@typescript-eslint/eslint-plugin": "^6.20.0", "@typescript-eslint/parser": "^6.20.0", - "cheerio": "^1.0.0-rc.12", "eslint": "^8.56.0", "eslint-config-airbnb-base": "^15.0.0", "eslint-config-airbnb-typescript": "^17.1.0", @@ -53,7 +52,6 @@ "husky": "^8.0.1", "jest": "^29.3.1", "lint-staged": "^12.4.2", - "outdent": "^0.8.0", "prettier": "^3.2.5", "pretty-quick": "^4.0.0", "ts-jest": "^29.0.3", @@ -65,7 +63,9 @@ "bytebuffer": "^5.0.1", "debug": "^4.3.4", "ini": "^2.0.0", - "regedit": "^5.1.1" + "regedit": "^5.1.1", + "cheerio": "^1.0.0-rc.12", + "outdent": "^0.8.0" }, "husky": { "hooks": { diff --git a/src/ApiHelper/scripts/scrapeSimvars.ts b/src/ApiHelper/scripts/scrapeSimvars.ts new file mode 100644 index 0000000..0297ff5 --- /dev/null +++ b/src/ApiHelper/scripts/scrapeSimvars.ts @@ -0,0 +1,143 @@ +import * as fs from 'fs'; +import * as cheerio from 'cheerio'; +import { outdent } from 'outdent'; // TODO: this should be part of dev dependencies +import { SimConnectDataType } from '../../index'; + +/** + * Running manually: + * npx ts-node .\src\ApiHelper\scripts\scrapeSimvars.ts + */ + +type SimvarSpecs = { + name: string; + description: string; + units: string; + type: SimConnectDataType; + settable: boolean; +}; + +async function clone() { + const pages = [ + 'Aircraft_SimVars/Aircraft_AutopilotAssistant_Variables.htm', + 'Aircraft_SimVars/Aircraft_Brake_Landing_Gear_Variables.htm', + 'Aircraft_SimVars/Aircraft_Control_Variables.htm', + 'Aircraft_SimVars/Aircraft_Electrics_Variables.htm', + 'Aircraft_SimVars/Aircraft_Engine_Variables.htm', + 'Aircraft_SimVars/Aircraft_FlightModel_Variables.htm', + 'Aircraft_SimVars/Aircraft_Fuel_Variables.htm', + 'Aircraft_SimVars/Aircraft_Misc_Variables.htm', + 'Aircraft_SimVars/Aircraft_RadioNavigation_Variables.htm', + 'Aircraft_SimVars/Aircraft_System_Variables.htm', + 'Helicopter_Variables.htm', + 'Camera_Variables.htm', + 'Miscellaneous_Variables.htm', + 'Services_Variables.htm', + ]; + + const results = await Promise.all( + pages.map(async url => + extractTables(`https://docs.flightsimulator.com/html/Programming_Tools/SimVars/${url}`) + ) + ); + + const allSimvars: { [key: string]: SimvarSpecs } = {}; + + results.forEach(page => { + page.forEach(simvar => { + allSimvars[simvar.name] = simvar; + }); + }); + + const fileContent = createOutputFile(allSimvars); + + fs.writeFile('generated/simvars.ts', fileContent, err => { + if (err) { + console.error(err); + } + // file written successfully + }); +} + +async function extractTables(url: string): Promise { + const xml = await fetch(url).then(res => res.text()); + const $ = cheerio.load(xml); + const rows = $('table:has(th:contains("Simulation Variable")) tr:has(td)'); + + const output: SimvarSpecs[] = []; + + for (let i = 0; i < rows.length; i++) { + // Process the rows and create arrays per row + const cells = $(rows[i]).find('td'); + const settable = $(cells).find('span.checkmark_circle_red').length === 0; + + const simvarNames = $(cells[0]).text().split('\n'); + simvarNames.forEach(name => + output.push({ + name: name.trim(), + description: $(cells[1]).html() || '', + units: correctUnits($(cells[2]).text()), + type: inferTypeFromUnit($(cells[2]).text()), + settable, + }) + ); + } + + return output; +} + +function correctUnits(originalValue: string): string { + if (originalValue.toUpperCase() === 'STRING') return ''; + if (originalValue.toUpperCase().includes('STRUCT')) return ''; + return originalValue; +} + +function inferTypeFromUnit(type: string): SimConnectDataType { + if (type.includes('Bool')) return SimConnectDataType.INT32; + if (type.includes('Enum')) return SimConnectDataType.INT32; + if (type.includes('Mask')) return SimConnectDataType.INT32; + if (type.includes('String')) { + if (type.includes('256')) return SimConnectDataType.STRING256; + if (type.includes('64')) return SimConnectDataType.STRING64; + if (type.includes('32')) return SimConnectDataType.STRING32; + if (type.includes('8')) return SimConnectDataType.STRING8; + return SimConnectDataType.STRINGV; + } + + return SimConnectDataType.FLOAT64; +} + +clone(); + +function createOutputFile(simvars: { [key: string]: SimvarSpecs }) { + let output = ''; + Object.values(simvars).forEach(simvar => { + output += outdent({ trimTrailingNewline: false })` + ${outdent} + /** ${simvar.description} */ + '${simvar.name}': { + name: '${simvar.name}', + units: '${simvar.units.split('\n')[0]}', + dataType: SimConnectDataType.${SimConnectDataType[simvar.type]}, + settable: ${simvar.settable}, + }, + `; + }); + + return outdent` + import { SimConnectDataType } from '../dist'; + + export type PredefinedVariable = { + name: string; + units: string; + dataType: SimConnectDataType; + settable: boolean; + }; + + export const simvarPredefinitions = { + ${output} + } as const satisfies { [key: string]: PredefinedVariable }; + + export type SimvarPredefinitions = typeof simvarPredefinitions; + + `; +}