• global-modifying-module.d.ts
  
• global-plugin.d.ts
  
• global.d.ts
  
• module-class.d.ts
  
• module-function.d.ts
  
• module-plugin.d.ts
  
• module.d.ts
  

// Type definitions for [~THE LIBRARY NAME~] [~OPTIONAL VERSION NUMBER~]
// Project: [~THE PROJECT NAME~]
// Definitions by: [~YOUR NAME~] <[~A URL FOR YOU~]>




declare global {
    
    interface String {
        fancyFormat(opts: StringFormatOptions): string;
    }
}


export interface StringFormatOptions {
    fancinessLevel: number;
}


export function doSomething(): void;


export { };

global-plugin.d.ts

// Type definitions for [~THE LIBRARY NAME~] [~OPTIONAL VERSION NUMBER~]
// Project: [~THE PROJECT NAME~]
// Definitions by: [~YOUR NAME~] <[~A URL FOR YOU~]>




interface Number {
    toBinaryString(opts?: MyLibrary.BinaryFormatOptions): string;
    toBinaryString(callback: MyLibrary.BinaryFormatCallback, opts?: MyLibrary.BinaryFormatOptions): string;
}


declare namespace MyLibrary {
    type BinaryFormatCallback = (n: number) => string;
    interface BinaryFormatOptions {
        prefix?: string;
        padding: number;
    }
}

global.d.ts

// Type definitions for [~THE LIBRARY NAME~] [~OPTIONAL VERSION NUMBER~]
// Project: [~THE PROJECT NAME~]
// Definitions by: [~YOUR NAME~] <[~A URL FOR YOU~]>


declare function myLib(a: string): string;
declare function myLib(a: number): number;


interface myLib {
    name: string;
    length: number;
    extras?: string[];
}


declare namespace myLib {
    //~ We can write "myLib.timeout = 50;"
    let timeout: number;

    //~ We can access "myLib.version", but not change it
    const version: string;

    //~ There"s some class we can create via "let c = new myLib.Cat(42)"
    //~ Or reference e.g. "function f(c: myLib.Cat) { ... }
    class Cat {
        constructor(n: number);

        //~ We can read "c.age" from a "Cat" instance
        readonly age: number;

        //~ We can invoke "c.purr()" from a "Cat" instance
        purr(): void;
    }

    //~ We can declare a variable as
    //~   "var s: myLib.CatSettings = { weight: 5, name: "Maru" };"
    interface CatSettings {
        weight: number;
        name: string;
        tailLength?: number;
    }

    //~ We can write "const v: myLib.VetID = 42;"
    //~  or "const v: myLib.VetID = "bob";"
    type VetID = string | number;

    //~ We can invoke "myLib.checkCat(c)" or "myLib.checkCat(c, v);"
    function checkCat(c: Cat, s?: VetID);
}

module-class.d.ts

// Type definitions for [~THE LIBRARY NAME~] [~OPTIONAL VERSION NUMBER~]
// Project: [~THE PROJECT NAME~]
// Definitions by: [~YOUR NAME~] <[~A URL FOR YOU~]>






export as namespace myClassLib;


export = MyClass;


declare class MyClass {
    constructor(someParam?: string);

    someProperty: string[];

    myMethod(opts: MyClass.MyClassMethodOptions): number;
}


declare namespace MyClass {
    export interface MyClassMethodOptions {
        width?: number;
        height?: number;
    }
}

module-function.d.ts

// Type definitions for [~THE LIBRARY NAME~] [~OPTIONAL VERSION NUMBER~]
// Project: [~THE PROJECT NAME~]
// Definitions by: [~YOUR NAME~] <[~A URL FOR YOU~]>






export as namespace myFuncLib;


export = MyFunction;


declare function MyFunction(name: string): MyFunction.NamedReturnType;
declare function MyFunction(length: number): MyFunction.LengthReturnType;


declare namespace MyFunction {
    export interface LengthReturnType {
        width: number;
        height: number;
    }
    export interface NamedReturnType {
        firstName: string;
        lastName: string;
    }

    
    export const defaultName: string;
    export let defaultLength: number;
}

module-plugin.d.ts

// Type definitions for [~THE LIBRARY NAME~] [~OPTIONAL VERSION NUMBER~]
// Project: [~THE PROJECT NAME~]
// Definitions by: [~YOUR NAME~] <[~A URL FOR YOU~]>




import * as m from "someModule";


import * as other from "anotherModule";


declare module "someModule" {
    
    export function theNewMethod(x: m.foo): other.bar;

    
    export interface SomeModuleOptions {
        someModuleSetting?: string;
    }

    
    export interface MyModulePluginOptions {
        size: number;
    }
}

module.d.ts

// Type definitions for [~THE LIBRARY NAME~] [~OPTIONAL VERSION NUMBER~]
// Project: [~THE PROJECT NAME~]
// Definitions by: [~YOUR NAME~] <[~A URL FOR YOU~]>




export as namespace myLib;


export function myMethod(a: string): string;
export function myOtherMethod(a: number): number;


export interface someType {
    name: string;
    length: number;
    extras?: string[];
}


export const myField: number;


export namespace subProp {
    
    export function foo(): void;
}