Back to typescript-generator Wiki
version 1.6.171 and above

Modules and Namespaces

TypeScript language offers different ways how to organize declarations and code. In addition to global scope, declarations can also be organized using modules and namespaces. Following parameters controls what kind of output will be generated.

outputFile

Path and name of generated TypeScript file. Required parameter.

outputFileType

TypeScript file type, can be declarationFile (.d.ts) or implementationFile (.ts).
Default value is declarationFile.

outputKind

Kind of generated TypeScript output, allowed values are global, module or ambientModule.
Value global means that declarations will be in global scope or namespace (no module).
Value module means that generated file will contain top-level export declarations.
Value ambientModule means that generated declarations will be wrapped in declare module "mod" { } declaration.
Required parameter.

module

Name of generated ambient module.
Used when outputKind is set to ambientModule.

namespace

Generates specified namespace. Not recommended to combine with modules. Default is no namespace.

umdNamespace

Generates declaration file in UMD format with specified namespace (export as namespace declaration is generated).
Can be used when outputKind is set to module.

Supported output variants

Table bellow shows output variants by examples. Primarily typescript-generator produces declaration files (left column) but it can be also configured to produce implementation files (right column). Table also contains info how to configure typescript-generator to produce particular variant. Keywords commented out are optional and typescript-generator doesn't emit them.

declaration file (.d.ts) implementation file (.ts)
global
outputKind = global
outputFileType = implementationFile
outputKind = global
/*declare*/ interface Data {}
interface Data {}
function test() {}
global
with
namespace
outputKind = global
namespace = "NS"
outputFileType = implementationFile
outputKind = global
namespace = "NS"
declare namespace NS {
    /*export*/ interface Data {}
}
namespace NS {
    export interface Data {}
    export function test() {}
}
module
outputKind = ambientModule
module = "mod"
outputKind = module
outputFileType = implementationFile
outputKind = module
declare module "mod" {
    /*export*/ interface Data {}
}
export interface Data {}
export interface Data {}
export function test() {}
module
with
namespace
outputKind = ambientModule
module = "mod"
namespace = "NS"
outputKind = module
namespace = "NS"
outputFileType = implementationFile
outputKind = module
namespace = "NS"
declare module "mod" {
    /*export*/ namespace NS {
        /*export*/ interface Data {}
    }
}
export namespace NS {
    /*export*/ interface Data {}
}
export namespace NS {
    export interface Data {}
    export function test() {}
}
Supported