From 45c696a0df2c1559e828311473f1c8ff4981031a Mon Sep 17 00:00:00 2001
From: Derek Rada <drada@markettrack.com>
Date: Wed, 13 Jun 2018 17:13:16 -0400
Subject: [PATCH 1/2] namespace changes

---
 types/postmark/index.d.ts | 423 +++++++++++++++++++-------------------
 1 file changed, 213 insertions(+), 210 deletions(-)

diff --git a/types/postmark/index.d.ts b/types/postmark/index.d.ts
index 8a054e17e0..2f77040930 100644
--- a/types/postmark/index.d.ts
+++ b/types/postmark/index.d.ts
@@ -2,215 +2,218 @@
 // Project: http://wildbit.github.io/postmark.js
 // Definitions by: Ben Bayard <https://github.com/benbayard>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.4
 
-interface PostmarkError {
-    status: number;
-    message: string;
-    code: number;
+export = Postmark;
+
+declare function Postmark(apiKey: string, options: Partial<Postmark.Options>): Postmark.Client;
+declare namespace Postmark {
+    const defaults: Options;
+
+    interface PostmarkError {
+        status: number;
+        message: string;
+        code: number;
+    }
+
+    interface PostmarkMessageHeader {
+        Name: string;
+        Value: string;
+    }
+
+    interface PostmarkAttachment {
+        Content: string;
+        Name: string;
+        ContentType: string;
+    }
+
+    interface Filter {
+        count: number;
+        offset: number;
+    }
+
+    interface PostmarkMessageWithTemplate {
+        To: string;
+        From: string;
+        Cc?: string;
+        Bcc?: string;
+        ReplyTo?: string;
+        TemplateId?: string;
+        TemplateModel?: any;
+        Tag?: string;
+        Subject?: string;
+        TrackOpens?: boolean;
+        TrackLinks?: string;
+        Headers?: PostmarkMessageHeader[];
+    }
+
+    interface PostmarkMessage {
+        To: string;
+        From: string;
+        Cc?: string;
+        Bcc?: string;
+        ReplyTo?: string;
+        Tag?: string;
+        Subject?: string;
+        HTMLBody?: string;
+        TextBody?: string;
+        TrackOpens?: boolean;
+        TrackLinks?: string;
+        Headers?: PostmarkMessageHeader[];
+        Attachments?: PostmarkAttachment[];
+    }
+
+    interface Sender {
+        Color: string;
+        RawEmailEnabled: boolean;
+        SmtpApiActivated: boolean;
+        DeliveryHookUrl: string;
+        InboundHookUrl: string;
+        BounceHookUrl: boolean;
+        IncludeBounceContentInHook: boolean;
+        OpenHookUrl: boolean;
+        PostFirstOpenOnly: boolean;
+        TrackOpens: boolean;
+        TrackLinks: string;
+        InboundDomain: string;
+        InboundSpamThreshold: number;
+    }
+
+    interface TemplateValidator<T extends object> {
+        Subject: string;
+        HtmlBody: string;
+        TextBody: string;
+        TestRenderModel?: T;
+        InlineCssForHtmlTestRender?: boolean;
+    }
+
+    type PostmarkCallback<T extends object = any> = ((e: PostmarkError, ret: T) => void) | undefined;
+
+    interface SimpleOptions {
+        ssl: boolean;
+        requestHost: string;
+    }
+
+    interface Options extends SimpleOptions {
+        requestFactory(
+            options: SimpleOptions
+        ): (
+            path?: string,
+            type?: string,
+            content?: PostmarkMessage,
+            callback?: PostmarkCallback
+        ) => any;
+    }
+
+    class Client {
+        constructor(serverKey: string, options?: Partial<Options>);
+        send(message: PostmarkMessage, callback: PostmarkCallback): void;
+        sendEmailWithTemplate(
+            message: PostmarkMessageWithTemplate,
+            callback: PostmarkCallback
+        ): void;
+        batch(message: PostmarkMessage[], callback: PostmarkCallback): void;
+        sendEmail(message: PostmarkMessage, callback: PostmarkCallback): void;
+        sendEmailBatch(message: PostmarkMessage[], callback: PostmarkCallback): void;
+        getDeliveryStatistics(callback: PostmarkCallback): void;
+        getBounces(filter: Partial<Filter>, callback: PostmarkCallback): void;
+        getBounce(id: number, callback: PostmarkCallback): void;
+        getBounceDump(id: number, callback: PostmarkCallback): void;
+        activateBounce(id: number, callback: PostmarkCallback): void;
+        getBounceTags(callback: PostmarkCallback): void;
+        getServer(callback: PostmarkCallback): void;
+        editServer<T extends keyof Sender>(options: Pick<Sender, T>, callback: PostmarkCallback): void;
+        getOutboundMessages(filter: Partial<Filter>, callback: PostmarkCallback): void;
+        getOutboundMessageDetails(id: number, callback: PostmarkCallback): void;
+        getMessageOpens(filter: Partial<Filter>, callback: PostmarkCallback): void;
+        getMessageOpensForSingleMessage(id: number, filter: Partial<Filter>, callback: PostmarkCallback): void;
+        getInboundMessages(filter: Partial<Filter>, callback: PostmarkCallback): void;
+        getInboundMessageDetails(id: number, callback: PostmarkCallback): void;
+        bypassBlockedInboundMessage(id: number, callback: PostmarkCallback): void;
+        retryInboundHookForMessage(id: number, callback: PostmarkCallback): void;
+        getOuboundOverview(filter: Partial<Filter>, callback: PostmarkCallback): void;
+        validateTemplate<T extends object>(templateObject: TemplateValidator<T>, callback: PostmarkCallback): void;
+    }
+
+    interface CreateSignature {
+        FromEmail: string;
+        Name: string;
+        ReplyToEmail?: string;
+        ReturnPathDomain?: string;
+    }
+
+    interface CreateServer {
+        Name: string;
+        Color?: string;
+        RawEmailEnabled?: boolean;
+        SmtpApiActivated?: boolean;
+        DeliveryHookUrl?: string;
+        InboundHookUrl?: string;
+        BounceHookUrl?: string;
+        IncludeBounceContentInHook?: boolean;
+        OpenHookUrl?: string;
+        PostFirstOpenOnly?: boolean;
+        TrackOpens?: boolean;
+        TrackLinks?: string;
+        InboundDomain?: string;
+        InboundSpamThreshold?: number;
+    }
+
+    interface CreateDomain {
+        Name: string;
+        ReturnPathDomain?: string;
+    }
+
+    class AdminClient {
+        constructor(apiKey: string, options: Partial<Options>);
+        listSenderSignatures(query: Partial<Filter>, callback: PostmarkCallback): void;
+        createSenderSignature(options: CreateSignature, callback: PostmarkCallback): void;
+        editSenderSignature<T extends keyof CreateSignature>(
+            id: number,
+            options: Partial<Pick<CreateSignature, T>>,
+            callback: PostmarkCallback
+        ): void;
+        deleteSenderSignature(id: number, callback: PostmarkCallback): void;
+        resendSenderSignatureConfirmation(id: number, callback: PostmarkCallback): void;
+        verifySenderSignatureSPF(id: number, callback: PostmarkCallback): void;
+        requestNewDKIMForSenderSignature(id: number, callback: PostmarkCallback): void;
+        getServer(id: number, callback: PostmarkCallback): void;
+        createServer(options: CreateServer, callback: PostmarkCallback): void;
+        editServer<T extends keyof CreateServer>(
+            id: number,
+            options: Pick<CreateServer, T>,
+            callback: PostmarkCallback
+        ): void;
+        deleteServer(id: number, callback: PostmarkCallback): void;
+        listServers(query: Partial<Filter>, callback: PostmarkCallback): void;
+        listDomains(query: Partial<Filter>, callback: PostmarkCallback): void;
+        getDomain(id: number, callback: PostmarkCallback): void;
+        createDomain(
+            options: CreateDomain,
+            callback: PostmarkCallback
+        ): void;
+        editDomain<T extends keyof CreateDomain>(
+            id: number,
+            options: Pick<CreateDomain, T>,
+            callback: PostmarkCallback
+        ): void;
+        deleteDomain(id: number, callback: PostmarkCallback): void;
+        verifyDomainSPF(id: number, callback: PostmarkCallback): void;
+        rotateDKIMForDomain(id: number, callback: PostmarkCallback): void;
+    }
+
+    interface ClientClass {
+        new(serverKey: string, options: Partial<Options>): Client;
+    }
+
+    interface AdminClientClass {
+        new(apiKey: string, options: Partial<Options>): AdminClient;
+    }
+
+    interface Postmark {
+        (apiKey: string, options: Partial<Options>): void;
+        defaults: Options;
+        Client: ClientClass;
+        AdminClient: AdminClientClass;
+    }
 }
-
-interface PostmarkMessageHeader {
-    Name: string;
-    Value: string;
-}
-
-interface PostmarkAttachment {
-    Content: string;
-    Name: string;
-    ContentType: string;
-}
-
-interface Filter {
-    count: number;
-    offset: number;
-}
-
-interface PostmarkMessageWithTemplate {
-    To: string;
-    From: string;
-    Cc?: string;
-    Bcc?: string;
-    ReplyTo?: string;
-    TemplateId?: string;
-    TemplateModel?: any;
-    Tag?: string;
-    Subject?: string;
-    TrackOpens?: boolean;
-    TrackLinks?: string;
-    Headers?: PostmarkMessageHeader[];
-}
-
-interface PostmarkMessage {
-    To: string;
-    From: string;
-    Cc?: string;
-    Bcc?: string;
-    ReplyTo?: string;
-    Tag?: string;
-    Subject?: string;
-    HTMLBody?: string;
-    TextBody?: string;
-    TrackOpens?: boolean;
-    TrackLinks?: string;
-    Headers?: PostmarkMessageHeader[];
-    Attachments?: PostmarkAttachment[];
-}
-
-interface Sender {
-    Color: string;
-    RawEmailEnabled: boolean;
-    SmtpApiActivated: boolean;
-    DeliveryHookUrl: string;
-    InboundHookUrl: string;
-    BounceHookUrl: boolean;
-    IncludeBounceContentInHook: boolean;
-    OpenHookUrl: boolean;
-    PostFirstOpenOnly: boolean;
-    TrackOpens: boolean;
-    TrackLinks: string;
-    InboundDomain: string;
-    InboundSpamThreshold: number;
-}
-
-interface TemplateValidator<T extends object> {
-    Subject: string;
-    HtmlBody: string;
-    TextBody: string;
-    TestRenderModel?: T;
-    InlineCssForHtmlTestRender?: boolean;
-}
-
-type PostmarkCallback<T extends object = any> = ((e: PostmarkError, ret: T) => void) | undefined;
-
-interface SimpleOptions {
-    ssl: boolean;
-    requestHost: string;
-}
-
-interface Options extends SimpleOptions {
-    requestFactory(
-        options: SimpleOptions
-    ): (
-        path?: string,
-        type?: string,
-        content?: PostmarkMessage,
-        callback?: PostmarkCallback
-    ) => any;
-}
-
-declare class Client {
-    constructor(serverKey: string, options?: Partial<Options>);
-    send(message: PostmarkMessage, callback: PostmarkCallback): void;
-    sendEmailWithTemplate(
-        message: PostmarkMessageWithTemplate,
-        callback: PostmarkCallback
-    ): void;
-    batch(message: PostmarkMessage[], callback: PostmarkCallback): void;
-    sendEmail(message: PostmarkMessage, callback: PostmarkCallback): void;
-    sendEmailBatch(message: PostmarkMessage[], callback: PostmarkCallback): void;
-    getDeliveryStatistics(callback: PostmarkCallback): void;
-    getBounces(filter: Partial<Filter>, callback: PostmarkCallback): void;
-    getBounce(id: number, callback: PostmarkCallback): void;
-    getBounceDump(id: number, callback: PostmarkCallback): void;
-    activateBounce(id: number, callback: PostmarkCallback): void;
-    getBounceTags(callback: PostmarkCallback): void;
-    getServer(callback: PostmarkCallback): void;
-    editServer<T extends keyof Sender>(options: Pick<Sender, T>, callback: PostmarkCallback): void;
-    getOutboundMessages(filter: Partial<Filter>, callback: PostmarkCallback): void;
-    getOutboundMessageDetails(id: number, callback: PostmarkCallback): void;
-    getMessageOpens(filter: Partial<Filter>, callback: PostmarkCallback): void;
-    getMessageOpensForSingleMessage(id: number, filter: Partial<Filter>, callback: PostmarkCallback): void;
-    getInboundMessages(filter: Partial<Filter>, callback: PostmarkCallback): void;
-    getInboundMessageDetails(id: number, callback: PostmarkCallback): void;
-    bypassBlockedInboundMessage(id: number, callback: PostmarkCallback): void;
-    retryInboundHookForMessage(id: number, callback: PostmarkCallback): void;
-    getOuboundOverview(filter: Partial<Filter>, callback: PostmarkCallback): void;
-    validateTemplate<T extends object>(templateObject: TemplateValidator<T>, callback: PostmarkCallback): void;
-}
-
-interface CreateSignature {
-    FromEmail: string;
-    Name: string;
-    ReplyToEmail?: string;
-    ReturnPathDomain?: string;
-}
-
-interface CreateServer {
-    Name: string;
-    Color?: string;
-    RawEmailEnabled?: boolean;
-    SmtpApiActivated?: boolean;
-    DeliveryHookUrl?: string;
-    InboundHookUrl?: string;
-    BounceHookUrl?: string;
-    IncludeBounceContentInHook?: boolean;
-    OpenHookUrl?: string;
-    PostFirstOpenOnly?: boolean;
-    TrackOpens?: boolean;
-    TrackLinks?: string;
-    InboundDomain?: string;
-    InboundSpamThreshold?: number;
-}
-
-interface CreateDomain {
-    Name: string;
-    ReturnPathDomain?: string;
-}
-
-declare class AdminClient {
-    constructor(apiKey: string, options: Partial<Options>);
-    listSenderSignatures(query: Partial<Filter>, callback: PostmarkCallback): void;
-    createSenderSignature(options: CreateSignature, callback: PostmarkCallback): void;
-    editSenderSignature<T extends keyof CreateSignature>(
-        id: number,
-        options: Partial<Pick<CreateSignature, T>>,
-        callback: PostmarkCallback
-    ): void;
-    deleteSenderSignature(id: number, callback: PostmarkCallback): void;
-    resendSenderSignatureConfirmation(id: number, callback: PostmarkCallback): void;
-    verifySenderSignatureSPF(id: number, callback: PostmarkCallback): void;
-    requestNewDKIMForSenderSignature(id: number, callback: PostmarkCallback): void;
-    getServer(id: number, callback: PostmarkCallback): void;
-    createServer(options: CreateServer, callback: PostmarkCallback): void;
-    editServer<T extends keyof CreateServer>(
-        id: number,
-        options: Pick<CreateServer, T>,
-        callback: PostmarkCallback
-    ): void;
-    deleteServer(id: number, callback: PostmarkCallback): void;
-    listServers(query: Partial<Filter>, callback: PostmarkCallback): void;
-    listDomains(query: Partial<Filter>, callback: PostmarkCallback): void;
-    getDomain(id: number, callback: PostmarkCallback): void;
-    createDomain(
-        options: CreateDomain,
-        callback: PostmarkCallback
-    ): void;
-    editDomain<T extends keyof CreateDomain>(
-        id: number,
-        options: Pick<CreateDomain, T>,
-        callback: PostmarkCallback
-    ): void;
-    deleteDomain(id: number, callback: PostmarkCallback): void;
-    verifyDomainSPF(id: number, callback: PostmarkCallback): void;
-    rotateDKIMForDomain(id: number, callback: PostmarkCallback): void;
-}
-
-interface ClientClass {
-    new(serverKey: string, options: Partial<Options>): Client;
-}
-
-interface AdminClientClass {
-    new(apiKey: string, options: Partial<Options>): AdminClient;
-}
-
-interface Postmark {
-    (apiKey: string, options: Partial<Options>): void;
-    defaults: Options;
-    Client: ClientClass;
-    AdminClient: AdminClientClass;
-}
-
-declare var postmark: Postmark;
-
-export = postmark;

From e4c62c323b36298298b8460136073062adec4e9c Mon Sep 17 00:00:00 2001
From: Derek Rada <drada@markettrack.com>
Date: Wed, 13 Jun 2018 18:51:31 -0400
Subject: [PATCH 2/2] add promises/functions/interfaces

---
 types/postmark/index.d.ts        | 591 +++++++++++++++++++++++++++----
 types/postmark/postmark-tests.ts |  50 ++-
 2 files changed, 567 insertions(+), 74 deletions(-)

diff --git a/types/postmark/index.d.ts b/types/postmark/index.d.ts
index 2f77040930..24810299a7 100644
--- a/types/postmark/index.d.ts
+++ b/types/postmark/index.d.ts
@@ -1,12 +1,12 @@
-// Type definitions for postmark 1.3
+// Type definitions for postmark 1.4
 // Project: http://wildbit.github.io/postmark.js
 // Definitions by: Ben Bayard <https://github.com/benbayard>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.4
 
-export = Postmark;
+export = postmark;
 
-declare function Postmark(apiKey: string, options: Partial<Postmark.Options>): Postmark.Client;
+declare const postmark: Postmark.Postmark;
 declare namespace Postmark {
     const defaults: Options;
 
@@ -28,8 +28,8 @@ declare namespace Postmark {
     }
 
     interface Filter {
-        count: number;
-        offset: number;
+        count?: number;
+        offset?: number;
     }
 
     interface PostmarkMessageWithTemplate {
@@ -87,7 +87,7 @@ declare namespace Postmark {
         InlineCssForHtmlTestRender?: boolean;
     }
 
-    type PostmarkCallback<T extends object = any> = ((e: PostmarkError, ret: T) => void) | undefined;
+    type PostmarkCallback<T extends object = any> = ((e: PostmarkError, ret: T) => undefined) | undefined;
 
     interface SimpleOptions {
         ssl: boolean;
@@ -107,39 +107,99 @@ declare namespace Postmark {
 
     class Client {
         constructor(serverKey: string, options?: Partial<Options>);
-        send(message: PostmarkMessage, callback: PostmarkCallback): void;
-        sendEmailWithTemplate(
-            message: PostmarkMessageWithTemplate,
-            callback: PostmarkCallback
-        ): void;
-        batch(message: PostmarkMessage[], callback: PostmarkCallback): void;
-        sendEmail(message: PostmarkMessage, callback: PostmarkCallback): void;
-        sendEmailBatch(message: PostmarkMessage[], callback: PostmarkCallback): void;
-        getDeliveryStatistics(callback: PostmarkCallback): void;
-        getBounces(filter: Partial<Filter>, callback: PostmarkCallback): void;
-        getBounce(id: number, callback: PostmarkCallback): void;
-        getBounceDump(id: number, callback: PostmarkCallback): void;
-        activateBounce(id: number, callback: PostmarkCallback): void;
-        getBounceTags(callback: PostmarkCallback): void;
-        getServer(callback: PostmarkCallback): void;
-        editServer<T extends keyof Sender>(options: Pick<Sender, T>, callback: PostmarkCallback): void;
-        getOutboundMessages(filter: Partial<Filter>, callback: PostmarkCallback): void;
-        getOutboundMessageDetails(id: number, callback: PostmarkCallback): void;
-        getMessageOpens(filter: Partial<Filter>, callback: PostmarkCallback): void;
-        getMessageOpensForSingleMessage(id: number, filter: Partial<Filter>, callback: PostmarkCallback): void;
-        getInboundMessages(filter: Partial<Filter>, callback: PostmarkCallback): void;
-        getInboundMessageDetails(id: number, callback: PostmarkCallback): void;
-        bypassBlockedInboundMessage(id: number, callback: PostmarkCallback): void;
-        retryInboundHookForMessage(id: number, callback: PostmarkCallback): void;
-        getOuboundOverview(filter: Partial<Filter>, callback: PostmarkCallback): void;
-        validateTemplate<T extends object>(templateObject: TemplateValidator<T>, callback: PostmarkCallback): void;
+
+        send(message: PostmarkMessage): Promise<SendStatus>;
+        send(message: PostmarkMessage, callback: PostmarkCallback<SendStatus>): undefined;
+
+        sendEmailWithTemplate(message: PostmarkMessageWithTemplate): Promise<SendStatus>;
+        sendEmailWithTemplate(message: PostmarkMessageWithTemplate, callback: PostmarkCallback<SendStatus>): undefined;
+
+        batch(message: PostmarkMessage[]): Promise<SendStatus[]>;
+        batch(message: PostmarkMessage[], callback: PostmarkCallback<SendStatus[]>): undefined;
+
+        sendEmail(message: PostmarkMessage): Promise<SendStatus>;
+        sendEmail(message: PostmarkMessage, callback: PostmarkCallback<SendStatus>): undefined;
+
+        sendEmailBatch(message: PostmarkMessage[]): Promise<SendStatus[]>;
+        sendEmailBatch(message: PostmarkMessage[], callback: PostmarkCallback<SendStatus[]>): undefined;
+
+        // stats
+        getDeliveryStatistics(): Promise<DeliveryStats>;
+        getDeliveryStatistics(callback: PostmarkCallback<DeliveryStats>): undefined;
+
+        // bounces
+        getBounces(filter: BounceFilter): Promise<BouncesResult>;
+        getBounces(filter: BounceFilter, callback?: PostmarkCallback<BouncesResult>): undefined;
+
+        getBounce(id: number): Promise<Bounce>;
+        getBounce(id: number, callback?: PostmarkCallback<Bounce>): undefined;
+
+        getBounceDump(id: number): Promise<BounceDump>;
+        getBounceDump(id: number, callback?: PostmarkCallback<BounceDump>): undefined;
+
+        activateBounce(id: number): Promise<ActivatedBounceResult>;
+        activateBounce(id: number, callback?: PostmarkCallback<ActivatedBounceResult>): undefined;
+
+        getBounceTags(): Promise<string[]>;
+        getBounceTags(callback?: PostmarkCallback<string[]>): undefined;
+
+        // server
+        getServer(): Promise<Server>;
+        getServer(callback?: PostmarkCallback<Server>): undefined;
+
+        editServer(server: Partial<Server>): Promise<Server>;
+        editServer(server: Partial<Server>, callback?: PostmarkCallback<Server>): undefined;
+
+        // message info
+        getOutboundMessages(filter: OutboundMessageFilter): Promise<OutboundMessagesResult>;
+        getOutboundMessages(filter: OutboundMessageFilter, callback?: PostmarkCallback<OutboundMessagesResult>): undefined;
+
+        getOutboundMessageDetails(id: number): Promise<OutboundMessage>;
+        getOutboundMessageDetails(id: number, callback?: PostmarkCallback<OutboundMessage>): undefined;
+
+        getMessageOpens(filter: OpenMessageFilter): Promise<MessageOpensResult>;
+        getMessageOpens(filter: OpenMessageFilter, callback?: PostmarkCallback<MessageOpensResult>): undefined;
+
+        getMessageOpensForSingleMessage(id: number, filter: Filter): Promise<MessageOpensResult>;
+        getMessageOpensForSingleMessage(id: number, filter: Filter, callback?: PostmarkCallback<MessageOpensResult>): undefined;
+
+        getInboundMessages(filter: InboundMessageFilter): Promise<InboundMessagesResult>;
+        getInboundMessages(filter: InboundMessageFilter, callback?: PostmarkCallback<InboundMessagesResult>): undefined;
+
+        getInboundMessageDetails(id: number): Promise<InboundMessage>;
+        getInboundMessageDetails(id: number, callback?: PostmarkCallback<InboundMessage>): undefined;
+
+        bypassBlockedInboundMessage(id: number): Promise<GenericResult>;
+        bypassBlockedInboundMessage(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+
+        getOuboundOverview(filter: BaseFilter): Promise<OutboundOverview>;
+        getOuboundOverview(filter: BaseFilter, callback?: PostmarkCallback<OutboundOverview>): undefined;
+
+        retryInboundHookForMessage(id: number): Promise<GenericResult>;
+        retryInboundHookForMessage(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+
+        // templates
+        getTemplate(id: number): Promise<Template>;
+        getTemplate(id: number, callback?: PostmarkCallback<Template>): undefined;
+
+        createTemplate(template: Partial<Template>): Promise<TemplateBase>;
+        createTemplate(template: Partial<Template>, callback?: PostmarkCallback<TemplateBase>): undefined;
+
+        editTemplate(template: Partial<Template>): Promise<TemplateBase>;
+        editTemplate(template: Partial<Template>, callback?: PostmarkCallback<TemplateBase>): undefined;
+
+        getTemplates(filter: Filter): Promise<TemplatesResult>;
+        getTemplates(filter: Filter, callback?: PostmarkCallback<TemplatesResult>): undefined;
+
+        deleteTemplate(id: number): Promise<GenericResult>;
+        deleteTemplate(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+
+        validateTemplate<T extends object>(templateObject: TemplateValidator<T>): Promise<TemplateValidationResult<T>>;
+        validateTemplate<T extends object>(templateObject: TemplateValidator<T>, callback?: PostmarkCallback<TemplateValidationResult<T>>): undefined;
     }
 
-    interface CreateSignature {
+    interface CreateSignature extends UpdateSignature {
         FromEmail: string;
-        Name: string;
-        ReplyToEmail?: string;
-        ReturnPathDomain?: string;
     }
 
     interface CreateServer {
@@ -166,40 +226,64 @@ declare namespace Postmark {
 
     class AdminClient {
         constructor(apiKey: string, options: Partial<Options>);
-        listSenderSignatures(query: Partial<Filter>, callback: PostmarkCallback): void;
-        createSenderSignature(options: CreateSignature, callback: PostmarkCallback): void;
-        editSenderSignature<T extends keyof CreateSignature>(
-            id: number,
-            options: Partial<Pick<CreateSignature, T>>,
-            callback: PostmarkCallback
-        ): void;
-        deleteSenderSignature(id: number, callback: PostmarkCallback): void;
-        resendSenderSignatureConfirmation(id: number, callback: PostmarkCallback): void;
-        verifySenderSignatureSPF(id: number, callback: PostmarkCallback): void;
-        requestNewDKIMForSenderSignature(id: number, callback: PostmarkCallback): void;
-        getServer(id: number, callback: PostmarkCallback): void;
-        createServer(options: CreateServer, callback: PostmarkCallback): void;
-        editServer<T extends keyof CreateServer>(
-            id: number,
-            options: Pick<CreateServer, T>,
-            callback: PostmarkCallback
-        ): void;
-        deleteServer(id: number, callback: PostmarkCallback): void;
-        listServers(query: Partial<Filter>, callback: PostmarkCallback): void;
-        listDomains(query: Partial<Filter>, callback: PostmarkCallback): void;
-        getDomain(id: number, callback: PostmarkCallback): void;
-        createDomain(
-            options: CreateDomain,
-            callback: PostmarkCallback
-        ): void;
-        editDomain<T extends keyof CreateDomain>(
-            id: number,
-            options: Pick<CreateDomain, T>,
-            callback: PostmarkCallback
-        ): void;
-        deleteDomain(id: number, callback: PostmarkCallback): void;
-        verifyDomainSPF(id: number, callback: PostmarkCallback): void;
-        rotateDKIMForDomain(id: number, callback: PostmarkCallback): void;
+        listSenderSignatures(query: Filter): Promise<SenderSignaturesResults>;
+        listSenderSignatures(query: Filter, callback?: PostmarkCallback<SenderSignaturesResults>): undefined;
+
+        createSenderSignature(options: CreateSignature): Promise<SenderSignature>;
+        createSenderSignature(options: CreateSignature, callback?: PostmarkCallback<SenderSignature>): undefined;
+
+        editSenderSignature(id: number, options: UpdateSignature): Promise<SenderSignature>;
+        editSenderSignature(id: number, options: UpdateSignature, callback?: PostmarkCallback<SenderSignature>): undefined;
+
+        deleteSenderSignature(id: number): Promise<GenericResult>;
+        deleteSenderSignature(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+
+        resendSenderSignatureConfirmation(id: number): Promise<GenericResult>;
+        resendSenderSignatureConfirmation(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+
+        verifySenderSignatureSPF(id: number): Promise<SenderSignature>;
+        verifySenderSignatureSPF(id: number, callback?: PostmarkCallback<SenderSignature>): undefined;
+
+        requestNewDKIMForSenderSignature(id: number): Promise<GenericResult>;
+        requestNewDKIMForSenderSignature(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+
+        // servers
+        getServer(id: number): Promise<Server>;
+        getServer(id: number, callback?: PostmarkCallback<Server>): undefined;
+
+        createServer(options: CreateServer): Promise<Server>;
+        createServer(options: CreateServer, callback?: PostmarkCallback<Server>): undefined;
+
+        editServer(id: number, options: Partial<CreateServer>): Promise<Server>;
+        editServer(id: number, options: Partial<CreateServer>, callback?: PostmarkCallback<Server>): undefined;
+
+        deleteServer(id: number): Promise<GenericResult>;
+        deleteServer(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+
+        listServers(query: ServerFilter): Promise<ServersResult>;
+        listServers(query: ServerFilter, callback?: PostmarkCallback<ServersResult>): undefined;
+
+        // domains
+        listDomains(query: Filter): Promise<DomainsResult>;
+        listDomains(query: Filter, callback?: PostmarkCallback<DomainsResult>): undefined;
+
+        getDomain(id: number): Promise<Domain>;
+        getDomain(id: number, callback?: PostmarkCallback<Domain>): undefined;
+
+        createDomain(options: CreateDomain): Promise<Domain>;
+        createDomain(options: CreateDomain, callback?: PostmarkCallback<Domain>): undefined;
+
+        editDomain(id: number, options: Partial<CreateDomain>): Promise<Domain>;
+        editDomain(id: number, options: Partial<CreateDomain>, callback?: PostmarkCallback<Domain>): undefined;
+
+        deleteDomain(id: number): Promise<GenericResult>;
+        deleteDomain(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+
+        verifyDomainSPF(id: number): Promise<SenderSignature>;
+        verifyDomainSPF(id: number, callback?: PostmarkCallback<SenderSignature>): undefined;
+
+        rotateDKIMForDomain(id: number): Promise<RotateDKIMResult>;
+        rotateDKIMForDomain(id: number, callback?: PostmarkCallback<RotateDKIMResult>): undefined;
     }
 
     interface ClientClass {
@@ -211,9 +295,374 @@ declare namespace Postmark {
     }
 
     interface Postmark {
-        (apiKey: string, options: Partial<Options>): void;
+        (apiKey: string, options: Partial<Options>): Client;
         defaults: Options;
         Client: ClientClass;
         AdminClient: AdminClientClass;
     }
+
+    // server
+    interface Server extends Sender {
+        ID: number;
+        ApiTokens: string[];
+        ServerLink: string;
+        Name: string;
+    }
+
+    interface SendStatus {
+        To: string;
+        SubmittedAt: string;
+        MessageID: string;
+        ErrorCode: number;
+        Message: string;
+    }
+
+    // validation
+    interface ValidationError {
+        Message: string;
+        Line: number;
+        CharacterPosition: number;
+    }
+
+    interface ValidationSet {
+        ContentIsValid: boolean;
+        ValidationErrors: ValidationError[];
+        RenderedContent: string;
+    }
+
+    interface TemplateValidator<T extends object> {
+        Subject: string;
+        HtmlBody: string;
+        TextBody: string;
+        TestRenderModel?: T;
+        InlineCssForHtmlTestRender?: boolean;
+    }
+
+    // templates
+    interface TemplateBase {
+        Name: string;
+        TemplateId: number;
+        Active: boolean;
+    }
+
+    interface Template extends TemplateBase {
+        Subject: string;
+        HtmlBody: string;
+        TextBody: string;
+        AssociatedServerId: number;
+    }
+
+    // filters
+    interface BaseFilter extends Filter {
+        tag?: string;
+        todate?: string;
+        fromdate?: string;
+    }
+    interface BounceFilter extends BaseFilter {
+        type?: string;
+        inactive?: boolean;
+        emailFilter?: string;
+        messageID?: string;
+    }
+
+    interface OutboundMessageFilter extends BaseFilter {
+        recipient?: string;
+        fromemail?: string;
+        status?: string;
+    }
+
+    interface InboundMessageFilter extends OutboundMessageFilter {
+        mailboxhash?: string;
+        subject?: string;
+    }
+
+    interface OpenMessageFilter extends BaseFilter {
+        client_name?: string;
+        client_company?: string;
+        client_family?: string;
+        os_name?: string;
+        os_family?: string;
+        os_company?: string;
+        platform?: string;
+        region?: string;
+        city?: string;
+    }
+
+    interface ServerFilter extends Filter {
+        name?: string;
+    }
+
+    // bounces
+    interface Bounce {
+        ID: number;
+        Type: string;
+        TypeCode: number;
+        Name: string;
+        Tag: string;
+        MessageID: string;
+        ServerID: number;
+        Description: string;
+        Details: string;
+        Email: string;
+        From: string;
+        Subject: string;
+        BouncedAt: string;
+        DumpAvailable: boolean;
+        Inactive: boolean;
+        CanActivate: boolean;
+        Content: string;
+    }
+
+    interface BounceDump {
+        Body: string;
+    }
+
+    // tracking info
+    interface VendorTrackingInfo {
+        Name: string;
+        Company: string;
+        Family: string;
+    }
+
+    interface GeoTrackingInfo {
+        CountryISOCode: string;
+        Country: string;
+        RegionISOCode: string;
+        Region: string;
+        City: string;
+        Zip: string;
+        Coords: string;
+        IP: string;
+    }
+
+    interface BounceStats {
+        Name: string;
+        Count: number;
+        Type: string | undefined;
+    }
+
+    interface DeliveryStats {
+        InactiveMails: number;
+        Bounces: BounceStats[];
+    }
+
+    interface MessageOpens {
+        FirstOpen: boolean;
+        Client: VendorTrackingInfo;
+        OS: VendorTrackingInfo;
+        Platform: string;
+        UserAgent: string;
+        ReadSeconds: number;
+        Geo: GeoTrackingInfo;
+        MessageID: string;
+        ReceivedAt: string;
+        Tag: string;
+        Recipient: string;
+    }
+
+    interface ExpandedEmail {
+        Email: string;
+        Name: string;
+    }
+
+    // message events
+    interface MessageEvents {
+        Recipient: string;
+        Type: string;
+        ReceivedAt: string;
+        Details: MessageEventDetails;
+    }
+
+    interface MessageEventDetails {
+        Summary?: string;
+        BounceID?: string;
+        Link?: string;
+        ClickLocation?: string;
+        DeliveryMessage?: string;
+        DestinationServer?: string;
+        DestinationIP?: string;
+    }
+
+    // messages
+    interface MessageBase {
+        Tag: string;
+        MessageID: string;
+        From: string;
+        Cc: string;
+        Subject: string;
+        Status: string;
+        Attachments: PostmarkAttachment[];
+    }
+
+    interface OutboundMessageBase extends MessageBase {
+        To: ExpandedEmail[];
+        Recipients: string[];
+        ReceivedAt: string;
+        TrackOpens: boolean;
+        TrackLinks: string;
+    }
+
+    interface OutboundMessage extends OutboundMessageBase {
+        TextBody: string;
+        HtmlBody: string;
+        Body: string;
+        MessageEvents: MessageEvents[];
+    }
+
+    interface InboundMessageBase extends MessageBase {
+        FromName: string;
+        FromFull: ExpandedEmail;
+        To: string;
+        ToFull: ExpandedEmail[];
+        CcFull: ExpandedEmail[];
+        ReplyTo: string;
+        OriginalRecipient: string;
+        Date: string;
+        MailboxHash: string;
+    }
+
+    interface InboundMessage extends InboundMessageBase {
+        TextBody: string;
+        HtmlBody: string;
+        Headers: PostmarkMessageHeader[];
+        BlockedReason?: string;
+        MessageEvents: MessageEvents[];
+    }
+
+    // Results
+    interface GenericResult {
+        Message: string;
+        ErrorCode?: number;
+    }
+
+    interface PaginatedResult {
+        TotalCount: number;
+    }
+
+    interface ActivatedBounceResult extends GenericResult {
+        Bounce: Bounce;
+    }
+
+    interface BouncesResult extends PaginatedResult {
+        Bounces: Bounce[];
+    }
+
+    interface TemplatesResult extends PaginatedResult {
+        Templates: TemplateBase[];
+    }
+
+    interface MessageOpensResult extends PaginatedResult {
+        Opens: MessageOpens[];
+    }
+
+    interface OutboundMessagesResult extends PaginatedResult {
+        Messages: OutboundMessageBase[];
+    }
+
+    interface InboundMessagesResult extends PaginatedResult {
+        InboundMessages: InboundMessageBase[];
+    }
+
+    interface TemplateValidationResult<T extends object = any> {
+        AllContentIsValid: boolean;
+        HtmlBody: ValidationSet;
+        TextBody: ValidationSet;
+        Subject: ValidationSet;
+        SuggestedTemplateModel: T;
+    }
+
+    interface SenderSignaturesResults extends PaginatedResult {
+        SenderSignatures: SenderSignatureBase[];
+    }
+
+    interface ServersResult extends PaginatedResult {
+        Servers: Server[];
+    }
+
+    interface DomainsResult extends PaginatedResult {
+        Domains: DomainBase[];
+    }
+
+    // sender signature
+    interface SenderSignatureBase {
+        Domain: string;
+        EmailAddress: string;
+        Name: string;
+        ReplyToEmailAddress: string;
+        Confirmed: boolean;
+        ID: number;
+    }
+
+    interface SPFRecord {
+        SPFHost: string;
+        SPFTextValue: string;
+        SPFVerified: boolean;
+    }
+
+    interface DKIMKey {
+        WeakDKIM: boolean;
+        DKIMHost: string;
+        DKIMVerified: boolean;
+        DKIMTextValue: string;
+        DKIMPendingHost: string;
+        DKIMPendingTextValue: string;
+        DKIMRevokedHost: string;
+        DKIMRevokedTextValue: string;
+        SafeToRemoveRevokedKeyFromDNS: boolean;
+        DKIMUpdateStatus: string;
+    }
+
+    interface VerificationDetails extends SPFRecord, DKIMKey {
+        ReturnPathDomain: string;
+        ReturnPathDomainCNAMEValue: string;
+    }
+
+    interface SenderSignature extends SenderSignatureBase, VerificationDetails {
+        ReturnPathDomainVerified: boolean;
+    }
+
+    interface UpdateSignature {
+        Name: string;
+        ReplyToEmail?: string;
+        ReturnPathDomain?: string;
+    }
+
+    // domain
+    interface DomainBase {
+        ID: number;
+        Name: string;
+        SPFVerified: boolean;
+        DKIMVerified: boolean;
+        WeakDKIM: boolean;
+        ReturnPathDomainVerified: boolean;
+    }
+
+    interface Domain extends DomainBase, VerificationDetails {
+    }
+
+    interface RotateDKIMResult extends DKIMKey {
+        Name: string;
+        ID: string;
+    }
+
+    // outbound overview
+    interface OutboundOverview {
+        Sent: number;
+        Bounced: number;
+        SMTPApiErrors: number;
+        BounceRate: number;
+        SpamComplaints: number;
+        SpamComplaintsRate: number;
+        Opens: number;
+        UniqueOpens: number;
+        Tracked: number;
+        WithLinkTracking: number;
+        WithOpenTracking: number;
+        TotalTrackedLinksSent: number;
+        UniqueLinksClicked: number;
+        TotalClicks: number;
+        WithClientRecorded: number;
+        WithPlatformRecorded: number;
+        WithReadTimeRecorded: number;
+    }
 }
diff --git a/types/postmark/postmark-tests.ts b/types/postmark/postmark-tests.ts
index 451b0051f4..f18bff2ef6 100644
--- a/types/postmark/postmark-tests.ts
+++ b/types/postmark/postmark-tests.ts
@@ -11,7 +11,7 @@ const templateValidator = {
   TextBody: '123535',
 };
 
-declare function callback(err: any, data: any): void;
+declare function callback(err: any, data: any): undefined;
 
 const client = new postmark.Client('124345', options);
 const adminClient = new postmark.AdminClient('1123235', options);
@@ -40,16 +40,40 @@ client.retryInboundHookForMessage(1, callback);
 client.getOuboundOverview(filter, callback);
 client.validateTemplate(templateValidator, callback);
 
+client.send(message).then(() => { });
+client.sendEmailWithTemplate(templateMessage).then(() => { });
+client.batch([message, message]).then(() => { });
+client.sendEmail(message).then(() => { });
+client.sendEmailBatch([message, message]).then(() => { });
+client.getDeliveryStatistics().then(() => { });
+client.getBounces(filter).then(() => { });
+client.getBounce(1).then(() => { });
+client.getBounceDump(1).then(() => { });
+client.activateBounce(1).then(() => { });
+client.getBounceTags().then(() => { });
+client.getServer().then(() => { });
+client.editServer(editSender).then(() => { });
+client.getOutboundMessages(filter).then(() => { });
+client.getOutboundMessageDetails(1).then(() => { });
+client.getMessageOpens(filter).then(() => { });
+client.getMessageOpensForSingleMessage(1, filter).then(() => { });
+client.getInboundMessages(filter).then(() => { });
+client.getInboundMessageDetails(1).then(() => { });
+client.bypassBlockedInboundMessage(1).then(() => { });
+client.retryInboundHookForMessage(1).then(() => { });
+client.getOuboundOverview(filter).then(() => { });
+client.validateTemplate(templateValidator).then(() => { });
+
 adminClient.listSenderSignatures(filter, callback);
 adminClient.createSenderSignature({FromEmail: '', Name: ''}, callback);
-adminClient.editSenderSignature(0, {ReplyToEmail: '123'}, callback);
+adminClient.editSenderSignature(0, {Name: '123'}, callback);
 adminClient.deleteSenderSignature(0, callback);
 adminClient.resendSenderSignatureConfirmation(0, callback);
 adminClient.verifySenderSignatureSPF(0, callback);
 adminClient.requestNewDKIMForSenderSignature(0, callback);
 adminClient.getServer(0, callback);
 adminClient.createServer({Name: '123'}, callback);
-adminClient.editServer(0, {Color: 'black'}, callback);
+adminClient.editServer(0, {Name: 'black'}, callback);
 adminClient.deleteServer(0, callback);
 adminClient.listServers(filter, callback);
 adminClient.listDomains(filter, callback);
@@ -59,3 +83,23 @@ adminClient.editDomain(0, {ReturnPathDomain: '/'}, callback);
 adminClient.deleteDomain(0, callback);
 adminClient.verifyDomainSPF(0, callback);
 adminClient.rotateDKIMForDomain(0, callback);
+
+adminClient.listSenderSignatures(filter).then(() => { });
+adminClient.createSenderSignature({ FromEmail: '', Name: '' }).then(() => { });
+adminClient.editSenderSignature(0, { Name: 'somename', ReplyToEmail: '123' }).then(() => { });
+adminClient.deleteSenderSignature(0).then(() => { });
+adminClient.resendSenderSignatureConfirmation(0).then(() => { });
+adminClient.verifySenderSignatureSPF(0).then(() => { });
+adminClient.requestNewDKIMForSenderSignature(0).then(() => { });
+adminClient.getServer(0).then(() => { });
+adminClient.createServer({ Name: '123' }).then(() => { });
+adminClient.editServer(0, { Name: 'black' }).then(() => { });
+adminClient.deleteServer(0).then(() => { });
+adminClient.listServers(filter).then(() => { });
+adminClient.listDomains(filter).then(() => { });
+adminClient.getDomain(0).then(() => { });
+adminClient.createDomain({ Name: '1234' }).then(() => { });
+adminClient.editDomain(0, { ReturnPathDomain: '/' }).then(() => { });
+adminClient.deleteDomain(0).then(() => { });
+adminClient.verifyDomainSPF(0).then(() => { });
+adminClient.rotateDKIMForDomain(0).then(() => { });