A big shoutout to Michał Lytek for the helpful solution. I recently discovered another technique that has proved useful in my own project.

By importing User, we can easily utilize it multiple times without having to repeatedly type import("./user").User throughout our codebase. This approach also allows us to seamlessly extend or re-export the imported module.

declare namespace Express {
    type User = import('./user').User;

    export interface Request {
        user: User;
        target: User;
        friend: User;
    }

    export class SuperUser implements User {
        superPower: string;
    }

    export { User as ExpressUser }
}

Enjoy coding! :)

In the interest of covering all bases:

• If you have an ambient module declaration (i.e., without any top-level import/export), it is globally available without requiring explicit import, but with a module declaration, you must import it in the consumer file.
• If you wish to import an existing type (exported from another file) into your ambient module declaration, you cannot do so with a top-level import as it would cease being an ambient declaration.

For example: ()

// index.d.ts
import { User } from "./models/user";
declare module 'express' {
  interface Session {
    user: User;
    uuid: string;
  }
}

This will extend the existing 'express' module with the new interface. https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation

However, to utilize this, you need to import it into your consumer file since it no longer qualifies as an ambient declaration and won't be globally available by default.

• Therefore, to import an existing type exported from another file, you must do so inside the declare block (in this example). In other scenarios where you aren't declaring a module, you can import inline elsewhere.

• To accomplish this, you cannot use a standard import like this:

  declare module B {
    import A from '../A'
    const a: A;
  }
  

  Due to current implementation rules causing confusion in resolving imported modules, TypeScript doesn't permit this. This results in the error message

  Import or export declaration in an ambient module declaration cannot reference module through relative module name.

  (If someone locates the relevant GitHub issue link, kindly edit this answer and include it. https://github.com/microsoft/TypeScript/issues/1720)

  Note that you can still do something like this:

  declare module B {
    import React from 'react';
    const a: A;
  }
  

  As this is an absolute path import rather than a relative one.

• The only appropriate approach within an ambient module is using dynamic import syntax (https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-9.html#import-types)

  declare namespace Express {
   interface Request {
     user: import("./user").User;
   }
  }
  

  As recommended in the accepted answer ()

• You can also perform global augmentation like this:

  import express = require('express');
  import { User } from "../models/user";
  
  declare global {
      namespace Express {
          interface Session {
              user: User;
              uuid: string;
          }
      }
  }
  

  Remember, global augmentation is only feasible in a module, not an ambient declaration. It will work only if imported into the consumer file, as mentioned in @masa's answer ()

All the points discussed above pertain to importing a module exported from elsewhere in your ambient modules. But what about importing an ambient module into another ambient module? (Useful for utilizing an existing ambient declaration in your own ambient module declaration and ensuring those ambient types are visible to consumers of your ambient module)

• You can utilize the

  /// <reference types="../../a" />

  directive

  // ambientA.d.ts
  interface A {
    t: string
  }
  

  // ambientB.d.ts
  /// <reference types="../ambientA.d.ts" />
  declare module B {
    const a: A;
    export { a };
  }
  

Links to other informative answers:

• Ambient declaration with an imported type in TypeScript

UPDATE

As of typescript 2.9, it appears that you can now import types into global modules. Refer to the approved response for more details.

REVISED ANSWER

The issue at hand seems to be more related to extending module declarations rather than class typing.

The exporting process is working correctly, as evidenced by successful compilation with the following code:

// app.ts  
import { User } from '../models/user'
let theUser = new User('theLogin', 'thePassword')

It looks like you are attempting to extend the module declaration of Express, and you are very close. This modification should solve the problem:

// index.d.ts
import { User } from "./models/user";
declare module 'express' {
  interface Session {
    user: User;
    uuid: string;
  }
}

However, the accuracy of this code relies on the original implementation of the express declaration file.

Is it possible to simply follow the logic using express-session?

own.d.ts:

import express = require('express');
import { User } from "../models/user";

declare global {
    namespace Express {
        interface Session {
            user: User;
            uuid: string;
        }
    }
}

In the main index.ts:

import express from 'express';
import session from 'express-session';
import own from './types/own';

const app = express();
app.get('/', (req, res) => {
    let username = req!.session!.user.login;
});

This code appears to compile without any issues. For the complete code, visit https://github.com/masa67/so39040108

Take a look at the following link:

You can define types within a module (such as in a file that uses import/export) and then merge those types into a global namespace.

The trick is to place the type definitions inside a

declare global { ... }

Here's an example that will be familiar to users of Cypress:

// start file: custom_command_login.ts

import { foo } from './utils';

Cypress.Commands.add('logIn', () => {
  
   // ...

}); 


// add custom command to Cypress namespace
// so that intellisense will correctly show the new command
// cy.logIn

declare global {
  namespace Cypress {
    interface Chainable {
       logIn();
    }
  }
}

// end file: custom_command_login.ts