react-native-windows 0.74.10 → 0.75.0-preview.1

package/src/private/webapis/performance/Performance.js

@@ -12,13 +12,15 @@
 
 import type {HighResTimeStamp, PerformanceEntryType} from './PerformanceEntry';
 import type {PerformanceEntryList} from './PerformanceObserver';
+import type {
+  PerformanceMarkOptions,
+  PerformanceMeasureOptions,
+} from './UserTiming';
 
 import warnOnce from '../../../../Libraries/Utilities/warnOnce';
 import EventCounts from './EventCounts';
 import MemoryInfo from './MemoryInfo';
-import NativePerformance from './NativePerformance';
-import NativePerformanceObserver from './NativePerformanceObserver';
-import {ALWAYS_LOGGED_ENTRY_TYPES, PerformanceEntry} from './PerformanceEntry';
+import {ALWAYS_LOGGED_ENTRY_TYPES} from './PerformanceEntry';
 import {warnNoNativePerformanceObserver} from './PerformanceObserver';
 import {
   performanceEntryTypeToRaw,
@@ -26,22 +28,17 @@ import {
 } from './RawPerformanceEntry';
 import {RawPerformanceEntryTypeValues} from './RawPerformanceEntry';
 import ReactNativeStartupTiming from './ReactNativeStartupTiming';
-
-type DetailType = mixed;
-
-export type PerformanceMarkOptions = {
-  detail?: DetailType,
-  startTime?: HighResTimeStamp,
-};
+import NativePerformance from './specs/NativePerformance';
+import NativePerformanceObserver from './specs/NativePerformanceObserver';
+import {PerformanceMark, PerformanceMeasure} from './UserTiming';
 
 declare var global: {
   // This value is defined directly via JSI, if available.
   +nativePerformanceNow?: ?() => number,
 };
 
-const getCurrentTimeStamp: () => HighResTimeStamp = global.nativePerformanceNow
-  ? global.nativePerformanceNow
-  : () => Date.now();
+const getCurrentTimeStamp: () => HighResTimeStamp =
+  NativePerformance?.now ?? global.nativePerformanceNow ?? (() => Date.now());
 
 // We want some of the performance entry types to be always logged,
 // even if they are not currently observed - this is either to be able to
@@ -54,49 +51,6 @@ if (NativePerformanceObserver?.setIsBuffered) {
   );
 }
 
-export class PerformanceMark extends PerformanceEntry {
-  detail: DetailType;
-
-  constructor(markName: string, markOptions?: PerformanceMarkOptions) {
-    super({
-      name: markName,
-      entryType: 'mark',
-      startTime: markOptions?.startTime ?? getCurrentTimeStamp(),
-      duration: 0,
-    });
-
-    if (markOptions) {
-      this.detail = markOptions.detail;
-    }
-  }
-}
-
-export type TimeStampOrName = HighResTimeStamp | string;
-
-export type PerformanceMeasureOptions = {
-  detail?: DetailType,
-  start?: TimeStampOrName,
-  end?: TimeStampOrName,
-  duration?: HighResTimeStamp,
-};
-
-export class PerformanceMeasure extends PerformanceEntry {
-  detail: DetailType;
-
-  constructor(measureName: string, measureOptions?: PerformanceMeasureOptions) {
-    super({
-      name: measureName,
-      entryType: 'measure',
-      startTime: 0,
-      duration: measureOptions?.duration ?? 0,
-    });
-
-    if (measureOptions) {
-      this.detail = measureOptions.detail;
-    }
-  }
-}
-
 function warnNoNativePerformance() {
   warnOnce(
     'missing-native-performance',

package/src/private/webapis/performance/PerformanceObserver.js

@@ -11,7 +11,6 @@
 import type {HighResTimeStamp, PerformanceEntryType} from './PerformanceEntry';
 
 import warnOnce from '../../../../Libraries/Utilities/warnOnce';
-import NativePerformanceObserver from './NativePerformanceObserver';
 import {PerformanceEntry} from './PerformanceEntry';
 import PerformanceEventTiming from './PerformanceEventTiming';
 import {
@@ -19,22 +18,25 @@ import {
   rawToPerformanceEntry,
   rawToPerformanceEntryType,
 } from './RawPerformanceEntry';
+import NativePerformanceObserver from './specs/NativePerformanceObserver';
 
 export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;
 
+export {PerformanceEntry} from './PerformanceEntry';
+
 export class PerformanceObserverEntryList {
-  _entries: PerformanceEntryList;
+  #entries: PerformanceEntryList;
 
   constructor(entries: PerformanceEntryList) {
-    this._entries = entries;
+    this.#entries = entries;
   }
 
   getEntries(): PerformanceEntryList {
-    return this._entries;
+    return this.#entries;
   }
 
   getEntriesByType(type: PerformanceEntryType): PerformanceEntryList {
-    return this._entries.filter(entry => entry.entryType === type);
+    return this.#entries.filter(entry => entry.entryType === type);
   }
 
   getEntriesByName(
@@ -42,9 +44,9 @@ export class PerformanceObserverEntryList {
     type?: PerformanceEntryType,
   ): PerformanceEntryList {
     if (type === undefined) {
-      return this._entries.filter(entry => entry.name === name);
+      return this.#entries.filter(entry => entry.name === name);
     } else {
-      return this._entries.filter(
+      return this.#entries.filter(
         entry => entry.name === name && entry.entryType === type,
       );
     }
@@ -98,11 +100,17 @@ const onPerformanceEntry = () => {
       const durationThreshold = observerConfig.entryTypes.get(entry.entryType);
       return entry.duration >= (durationThreshold ?? 0);
     });
-    observerConfig.callback(
-      new PerformanceObserverEntryList(entriesForObserver),
-      observer,
-      droppedEntriesCount,
-    );
+    if (entriesForObserver.length !== 0) {
+      try {
+        observerConfig.callback(
+          new PerformanceObserverEntryList(entriesForObserver),
+          observer,
+          droppedEntriesCount,
+        );
+      } catch (error) {
+        console.error(error);
+      }
+    }
   }
 };
 
@@ -167,11 +175,11 @@ function getSupportedPerformanceEntryTypes(): $ReadOnlyArray<PerformanceEntryTyp
  * observer.observe({ type: "event" });
  */
 export default class PerformanceObserver {
-  _callback: PerformanceObserverCallback;
-  _type: 'single' | 'multiple' | void;
+  #callback: PerformanceObserverCallback;
+  #type: 'single' | 'multiple' | void;
 
   constructor(callback: PerformanceObserverCallback) {
-    this._callback = callback;
+    this.#callback = callback;
   }
 
   observe(options: PerformanceObserverInit): void {
@@ -180,17 +188,17 @@ export default class PerformanceObserver {
       return;
     }
 
-    this._validateObserveOptions(options);
+    this.#validateObserveOptions(options);
 
     let requestedEntryTypes;
 
     if (options.entryTypes) {
-      this._type = 'multiple';
+      this.#type = 'multiple';
       requestedEntryTypes = new Map(
         options.entryTypes.map(t => [t, undefined]),
       );
     } else {
-      this._type = 'single';
+      this.#type = 'single';
       requestedEntryTypes = new Map([
         [options.type, options.durationThreshold],
       ]);
@@ -209,7 +217,7 @@ export default class PerformanceObserver {
     }
 
     registeredObservers.set(this, {
-      callback: this._callback,
+      callback: this.#callback,
       entryTypes: nextEntryTypes,
     });
 
@@ -276,7 +284,7 @@ export default class PerformanceObserver {
     applyDurationThresholds();
   }
 
-  _validateObserveOptions(options: PerformanceObserverInit): void {
+  #validateObserveOptions(options: PerformanceObserverInit): void {
     const {type, entryTypes, durationThreshold} = options;
 
     if (!type && !entryTypes) {
@@ -291,13 +299,13 @@ export default class PerformanceObserver {
       );
     }
 
-    if (this._type === 'multiple' && type) {
+    if (this.#type === 'multiple' && type) {
       throw new Error(
         "Failed to execute 'observe' on 'PerformanceObserver': This observer has performed observe({entryTypes:...}, therefore it cannot perform observe({type:...})",
       );
     }
 
-    if (this._type === 'single' && entryTypes) {
+    if (this.#type === 'single' && entryTypes) {
       throw new Error(
         "Failed to execute 'observe' on 'PerformanceObserver': This PerformanceObserver has performed observe({type:...}, therefore it cannot perform observe({entryTypes:...})",
       );

package/src/private/webapis/performance/RawPerformanceEntry.js

@@ -8,17 +8,16 @@
  * @flow strict
  */
 
+import type {PerformanceEntryType} from './PerformanceEntry';
 import type {
   RawPerformanceEntry,
   RawPerformanceEntryType,
-} from './NativePerformanceObserver';
-import type {PerformanceEntryType} from './PerformanceEntry';
+} from './specs/NativePerformanceObserver';
 
 import {PerformanceEntry} from './PerformanceEntry';
 import PerformanceEventTiming from './PerformanceEventTiming';
 
 export const RawPerformanceEntryTypeValues = {
-  UNDEFINED: 0,
   MARK: 1,
   MEASURE: 2,
   EVENT: 3,
@@ -56,10 +55,6 @@ export function rawToPerformanceEntryType(
       return 'measure';
     case RawPerformanceEntryTypeValues.EVENT:
       return 'event';
-    case RawPerformanceEntryTypeValues.UNDEFINED:
-      throw new TypeError(
-        "rawToPerformanceEntryType: UNDEFINED can't be cast to PerformanceEntryType",
-      );
     default:
       throw new TypeError(
         `rawToPerformanceEntryType: unexpected performance entry type received: ${type}`,

package/src/private/webapis/performance/ReactNativeStartupTiming.js

@@ -27,22 +27,22 @@ export default class ReactNativeStartupTiming {
   // We do NOT match web spect here for two reasons:
   // 1. The `ReactNativeStartupTiming` is non-standard API
   // 2. The timing information is relative to the time origin, which means `0` has valid meaning
-  _startTime: ?number;
-  _endTime: ?number;
-  _initializeRuntimeStart: ?number;
-  _initializeRuntimeEnd: ?number;
-  _executeJavaScriptBundleEntryPointStart: ?number;
-  _executeJavaScriptBundleEntryPointEnd: ?number;
+  #startTime: ?number;
+  #endTime: ?number;
+  #initializeRuntimeStart: ?number;
+  #initializeRuntimeEnd: ?number;
+  #executeJavaScriptBundleEntryPointStart: ?number;
+  #executeJavaScriptBundleEntryPointEnd: ?number;
 
   constructor(startUpTiming: ?ReactNativeStartupTimingLike) {
     if (startUpTiming != null) {
-      this._startTime = startUpTiming.startTime;
-      this._endTime = startUpTiming.endTime;
-      this._initializeRuntimeStart = startUpTiming.initializeRuntimeStart;
-      this._initializeRuntimeEnd = startUpTiming.initializeRuntimeEnd;
-      this._executeJavaScriptBundleEntryPointStart =
+      this.#startTime = startUpTiming.startTime;
+      this.#endTime = startUpTiming.endTime;
+      this.#initializeRuntimeStart = startUpTiming.initializeRuntimeStart;
+      this.#initializeRuntimeEnd = startUpTiming.initializeRuntimeEnd;
+      this.#executeJavaScriptBundleEntryPointStart =
         startUpTiming.executeJavaScriptBundleEntryPointStart;
-      this._executeJavaScriptBundleEntryPointEnd =
+      this.#executeJavaScriptBundleEntryPointEnd =
         startUpTiming.executeJavaScriptBundleEntryPointEnd;
     }
   }
@@ -51,41 +51,41 @@ export default class ReactNativeStartupTiming {
    * Start time of the RN app startup process. This is provided by the platform by implementing the `ReactMarker.setAppStartTime` API in the native platform code.
    */
   get startTime(): ?number {
-    return this._startTime;
+    return this.#startTime;
   }
 
   /**
    * End time of the RN app startup process. This is equal to `executeJavaScriptBundleEntryPointEnd`.
    */
   get endTime(): ?number {
-    return this._endTime;
+    return this.#endTime;
   }
 
   /**
    * Start time when RN runtime get initialized. This is when RN infra first kicks in app startup process.
    */
   get initializeRuntimeStart(): ?number {
-    return this._initializeRuntimeStart;
+    return this.#initializeRuntimeStart;
   }
 
   /**
    * End time when RN runtime get initialized. This is the last marker before ends of the app startup process.
    */
   get initializeRuntimeEnd(): ?number {
-    return this._initializeRuntimeEnd;
+    return this.#initializeRuntimeEnd;
   }
 
   /**
    * Start time of JS bundle being executed. This indicates the RN JS bundle is loaded and start to be evaluated.
    */
   get executeJavaScriptBundleEntryPointStart(): ?number {
-    return this._executeJavaScriptBundleEntryPointStart;
+    return this.#executeJavaScriptBundleEntryPointStart;
   }
 
   /**
    * End time of JS bundle being executed. This indicates all the synchronous entry point jobs are finished.
    */
   get executeJavaScriptBundleEntryPointEnd(): ?number {
-    return this._executeJavaScriptBundleEntryPointEnd;
+    return this.#executeJavaScriptBundleEntryPointEnd;
   }
 }

package/src/private/webapis/performance/UserTiming.js

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict
+ */
+
+import type {HighResTimeStamp} from './PerformanceEntry';
+
+import {PerformanceEntry} from './PerformanceEntry';
+
+type DetailType = mixed;
+
+export type PerformanceMarkOptions = {
+  detail?: DetailType,
+  startTime?: HighResTimeStamp,
+};
+
+export type TimeStampOrName = HighResTimeStamp | string;
+
+export type PerformanceMeasureOptions = {
+  detail?: DetailType,
+  start?: TimeStampOrName,
+  end?: TimeStampOrName,
+  duration?: HighResTimeStamp,
+};
+
+export class PerformanceMark extends PerformanceEntry {
+  detail: DetailType;
+
+  constructor(markName: string, markOptions?: PerformanceMarkOptions) {
+    super({
+      name: markName,
+      entryType: 'mark',
+      startTime: markOptions?.startTime ?? performance.now(),
+      duration: 0,
+    });
+
+    if (markOptions) {
+      this.detail = markOptions.detail;
+    }
+  }
+}
+
+export class PerformanceMeasure extends PerformanceEntry {
+  detail: DetailType;
+
+  constructor(measureName: string, measureOptions?: PerformanceMeasureOptions) {
+    super({
+      name: measureName,
+      entryType: 'measure',
+      startTime: 0,
+      duration: measureOptions?.duration ?? 0,
+    });
+
+    if (measureOptions) {
+      this.detail = measureOptions.detail;
+    }
+  }
+}

package/src/private/webapis/performance/{NativePerformance.js → specs/NativePerformance.js}

@@ -8,15 +8,16 @@
  * @format
  */
 
-import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
+import type {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
 
-import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
+import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export type NativeMemoryInfo = {[key: string]: ?number};
 
 export type ReactNativeStartupTiming = {[key: string]: ?number};
 
 export interface Spec extends TurboModule {
+  +now?: () => number;
   +mark: (name: string, startTime: number) => void;
   +measure: (
     name: string,

package/src/private/webapis/performance/{NativePerformanceObserver.js → specs/NativePerformanceObserver.js}

@@ -8,9 +8,9 @@
  * @format
  */
 
-import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
+import type {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
 
-import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
+import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export type RawPerformanceEntryType = number;
 

package/src/private/webapis/performance/{__mocks__ → specs/__mocks__}/NativePerformance.js

@@ -14,8 +14,8 @@ import type {
   Spec as NativePerformance,
 } from '../NativePerformance';
 
+import {RawPerformanceEntryTypeValues} from '../../RawPerformanceEntry';
 import NativePerformanceObserver from '../NativePerformanceObserver';
-import {RawPerformanceEntryTypeValues} from '../RawPerformanceEntry';
 
 const marks: Map<string, number> = new Map();
 

package/src/private/webapis/performance/{__mocks__ → specs/__mocks__}/NativePerformanceObserver.js

@@ -15,7 +15,7 @@ import type {
   Spec as NativePerformanceObserver,
 } from '../NativePerformanceObserver';
 
-import {RawPerformanceEntryTypeValues} from '../RawPerformanceEntry';
+import {RawPerformanceEntryTypeValues} from '../../RawPerformanceEntry';
 
 const reportingType: Set<RawPerformanceEntryType> = new Set();
 const isAlwaysLogged: Set<RawPerformanceEntryType> = new Set();
@@ -95,11 +95,10 @@ const NativePerformanceObserverMock: NativePerformanceObserver = {
     durationThresholds.set(entryType, durationThreshold);
   },
 
-  clearEntries: (entryType: RawPerformanceEntryType, entryName?: string) => {
+  clearEntries: (entryType?: RawPerformanceEntryType, entryName?: string) => {
     entries = entries.filter(
       e =>
-        (entryType !== RawPerformanceEntryTypeValues.UNDEFINED &&
-          e.entryType !== entryType) ||
+        (entryType != null && e.entryType !== entryType) ||
         (entryName != null && e.name !== entryName),
     );
   },

package/stubs/glog/logging.h

@@ -69,6 +69,7 @@ inline std::ostream &GetNullLog() noexcept {
 }
 
 #define LOG(b) GlogStub::GetNullLog()
+#define LOG_EVERY_N(severity, n) GlogStub::GetNullLog()
 
 typedef int LogSeverity;
 inline void FlushLogFiles(LogSeverity min_severity) {}

package/template/cpp-lib/proj/MyLib.vcxproj

@@ -20,7 +20,7 @@
   </PropertyGroup>
   <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.WindowsSdk.Default.props" Condition="Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.WindowsSdk.Default.props')" />
   <PropertyGroup Label="Fallback Windows SDK Versions">
-    <WindowsTargetPlatformVersion Condition=" '$(WindowsTargetPlatformVersion)' == '' ">10.0.19041.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition=" '$(WindowsTargetPlatformVersion)' == '' ">10.0.22621.0</WindowsTargetPlatformVersion>
     <WindowsTargetPlatformMinVersion Condition=" '$(WindowsTargetPlatformMinVersion)' == '' ">10.0.17763.0</WindowsTargetPlatformMinVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

package/template/cs-lib/proj/MyLib.csproj

@@ -24,7 +24,7 @@
   </PropertyGroup>
   <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.WindowsSdk.Default.props" Condition="Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.WindowsSdk.Default.props')" />
   <PropertyGroup Label="Fallback Windows SDK Versions">
-    <TargetPlatformVersion Condition=" '$(TargetPlatformVersion)' == '' ">10.0.19041.0</TargetPlatformVersion>
+    <TargetPlatformVersion Condition=" '$(TargetPlatformVersion)' == '' ">10.0.22621.0</TargetPlatformVersion>
     <TargetPlatformMinVersion Condition=" '$(TargetPlatformMinVersion)' == '' ">10.0.17763.0</TargetPlatformMinVersion>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">

package/template/metro.config.js

@@ -8,6 +8,11 @@ const rnwPath = fs.realpathSync(
   path.resolve(require.resolve('react-native-windows/package.json'), '..'),
 );
 
+//{{#devMode}} [devMode
+const rnwRootNodeModules = path.resolve(rnwPath, '..', 'node_modules');
+const rnwPackages = path.resolve(rnwPath, '..', 'packages');
+// devMode]{{/devMode}}
+
 /**
  * Metro configuration
  * https://facebook.github.io/metro/docs/configuration
@@ -16,6 +21,9 @@ const rnwPath = fs.realpathSync(
  */
 
 const config = {
+  //{{#devMode}} [devMode
+  watchFolders: [rnwPath, rnwRootNodeModules, rnwPackages],
+  // devMode]{{/devMode}}
   resolver: {
     blockList: exclusionList([
       // This stops "react-native run-windows" from causing the metro server to crash if its already running
@@ -27,6 +35,11 @@ const config = {
       new RegExp(`${rnwPath}/target/.*`),
       /.*\.ProjectImports\.zip/,
     ]),
+    //{{#devMode}} [devMode
+    extraNodeModules: {
+      'react-native-windows': rnwPath,
+    },
+    // devMode]{{/devMode}}
   },
   transformer: {
     getTransformOptions: async () => ({
@@ -35,8 +48,6 @@ const config = {
         inlineRequires: true,
       },
     }),
-    // This fixes the 'missing-asset-registry-path` error (see https://github.com/microsoft/react-native-windows/issues/11437)
-    assetRegistryPath: 'react-native/Libraries/Image/AssetRegistry',
   },
 };
 

package/templates/cpp-app/template.config.js

@@ -113,7 +113,7 @@ async function postInstall(config = {}, options = {}) {
       'test:windows': 'jest --config jest.config.windows.js',
     },
     devDependencies: {
-      '@rnx-kit/jest-preset': '^0.1.16',
+      '@rnx-kit/jest-preset': '^0.1.17',
     },
   });
 

package/templates/cpp-lib/example/metro.config.js

@@ -3,10 +3,10 @@ const fs = require('fs');
 const path = require('path');
 const escape = require('escape-string-regexp');
 const exclusionList = require('metro-config/src/defaults/exclusionList');
-const pak = require('../package.json');
+const pack = require('../package.json');
 
 const root = path.resolve(__dirname, '..');
-const modules = Object.keys({ ...pak.peerDependencies });
+const modules = Object.keys({ ...pack.peerDependencies });
 
 const rnwPath = fs.realpathSync(
   path.resolve(require.resolve('react-native-windows/package.json'), '..'),

package/templates/cpp-lib/template.config.js

@@ -212,7 +212,7 @@ async function postInstall(config = {}, options = {}) {
         'react-native-windows': rnwVersion,
       },
       devDependencies: {
-        '@rnx-kit/jest-preset': '^0.1.16',
+        '@rnx-kit/jest-preset': '^0.1.17',
       },
     });
 

package/templates/old/generateWrapper.js

@@ -7,6 +7,7 @@
  */
 
 const generateWindows = require('../../generate');
+const templateUtils = require('../templateUtils');
 
 function makeGenerateWindowsWrapper(
   language = 'cpp',
@@ -33,6 +34,8 @@ function makeGenerateWindowsWrapper(
   const postInstall = async (config = {}, options = {}) => {
     const experimentalFeatures = config?.project?.windows?.experimentalFeatures;
 
+    const rnwInfo = templateUtils.getRnwInfo(config, options);
+
     const generateOptions = {
       overwrite: !!options.overwrite,
       language,
@@ -41,7 +44,7 @@ function makeGenerateWindowsWrapper(
         experimentalFeatures?.UseExperimentalNuget ?? false,
       useWinUI3: experimentalFeatures?.UseWinUI3 ?? false,
       useHermes: experimentalFeatures?.UseHermes ?? true,
-      useDevMode: false,
+      useDevMode: rnwInfo.devMode,
       verbose: !!options.logging,
       telemetry: !!options.telemetry,
     };

package/types/modules/globals.d.ts

@@ -132,6 +132,10 @@ declare interface Headers {
   get(name: string): string | null;
   has(name: string): boolean;
   set(name: string, value: string): void;
+  entries(): IterableIterator<[string, string]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
 }
 
 declare var Headers: {