Here's an approach. I don't know if this is the 'correct' way of doing things, but it works for me with TypeScript 3.7.4.

1. Assuming your source files live in a folder src, create a new folder src/types and create a file global.d.ts in this folder.
2. Author your declarations using one of the following strategies:
   • If you need to import external types into your declaration file, use the following syntax:

import { Express } from 'express';

declare global {
  namespace NodeJS {
    interface Global {
      __EXPRESS_APP__: Express;
    }
  }
}

• If your declaration file does not contain any imports, the above will not work, and you'll need to use this syntax instead:

declare namespace NodeJS {
  interface Global {
    __CONNECTION_COUNT__: number;
  }
}

4. Make sure your global.d.ts file (and any other files you might add to src/types) is picked up by the TypeScript compiler, by adding the following to your tsconfig.json file:

{
  "paths": {
    "*": ["node_modules/*", "src/types/*"]
  }
}

5. Use the global variable as normal inside your code.

// Below, `app` will have the correct typings
const app = global.__EXPRESS_APP__;

As of node@16 the NodeJS.Global interface has been removed in favor of globalThis.

You can declare new global variable in a module file as:

declare global {
  var NEW_GLOBAL: string;
}

And in a non-module file (no top-level import/export) as:

declare var NEW_GLOBAL: string;

Important note: variable must be declared as var. let and const variables don't show up on globalThis.

You probably shouldn't be using a global variable for what you're trying to do, but…

to let TypeScript know about your own properties on the global object you need to augment the Global interface in a d.ts file:

export interface Global {
 myProp: string;
}

If all you want is to 'share' stuff across files (i.e. modules) you probably want to export from your modules rather than add to the global object.

globalThis is the future.

First, TypeScript files have two kinds of scopes

global scope

If your file hasn't any import or export line, this file would be executed in global scope that all declaration in it are visible outside this file.

So we would create global variables like this:

// xx.d.ts
declare var age: number

// or 
// xx.ts
// with or without declare keyword
var age: number

// other.ts
globalThis.age = 18 // no error

All magic come from var. Replace var with let or const won't work.

module scope

If your file has any import or export line, this file would be executed within its own scope that we need to extend global by declaration-merging.

// xx[.d].ts
declare global {
  var age: number;
}

// other.ts
globalThis.age = 18 // no error

You can see more about module in official docs

In TypeScript, declare blocks are used to describe your global variables. In other words, they are a way of telling TypeScript what it can expect in the global namespace — but it's your responsibility as a developer to make sure they are actually there.

The way you can create (and describe) global variables depends on the platform.

The browser (DOM)

import * as io from 'socket.io';

window.SocketServer = io.default();

declare global {
  interface Window {
    SocketServer: io.Server;
  }
}

Requires @types/socket.io. Is consumed by accessing window.SocketServer.

Node.js

import * as io from 'socket.io';

declare global {
  namespace NodeJS {
    interface Global {
      SocketServer: io.Server
    }
  }
}

global.SocketServer = io.default();

Requires @types/socket.io and @types/node. Is consumed by accessing global.SocketServer.

Universal

You can also describe a variable that is already a part of your environment and is accessible to both the client and the server.

An example of such a variable would be process — it's a part of Node.js environment, but build tools like Webpack can expose its contents to the client.

import * as io from 'socket.io';

declare global {
  var SocketServer: io.Server;
}

Which version of global declaration works always seems to depend on project setup. In your case, the following global.d.ts should work:

export {}; // make the file a module, to get rid of the warning

declare global {
    namespace NodeJS {
        interface Global {
            appRoot: string;
        }
    }
}

Also make sure that only either one of the definitions is present.