From 22399e3d188f6dad50bebf0ca84c114450d96747 Mon Sep 17 00:00:00 2001
From: Jinesh Shah <jineshshah36@gmail.com>
Date: Fri, 7 Sep 2018 13:03:42 -0400
Subject: [PATCH 1/4] updated postmark to allow named types

---
 types/postmark/index.d.ts        | 267 ++++++++++++++++++++++++-------
 types/postmark/postmark-tests.ts | 120 +++++++-------
 types/postmark/tsconfig.json     |  19 +--
 types/postmark/tslint.json       |   7 +-
 4 files changed, 278 insertions(+), 135 deletions(-)

diff --git a/types/postmark/index.d.ts b/types/postmark/index.d.ts
index 24810299a7..b2b7ac0cfc 100644
--- a/types/postmark/index.d.ts
+++ b/types/postmark/index.d.ts
@@ -1,12 +1,10 @@
 // Type definitions for postmark 1.4
 // Project: http://wildbit.github.io/postmark.js
-// Definitions by: Ben Bayard <https://github.com/benbayard>
+// Definitions by:  Ben Bayard <https://github.com/benbayard>
+//                  Jinesh Shah <https://github.com/jineshshah36>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.4
 
-export = postmark;
-
-declare const postmark: Postmark.Postmark;
 declare namespace Postmark {
     const defaults: Options;
 
@@ -87,7 +85,9 @@ declare namespace Postmark {
         InlineCssForHtmlTestRender?: boolean;
     }
 
-    type PostmarkCallback<T extends object = any> = ((e: PostmarkError, ret: T) => undefined) | undefined;
+    type PostmarkCallback<T extends object = any> =
+        | ((e: PostmarkError, ret: T) => undefined)
+        | undefined;
 
     interface SimpleOptions {
         ssl: boolean;
@@ -109,36 +109,64 @@ declare namespace Postmark {
         constructor(serverKey: string, options?: Partial<Options>);
 
         send(message: PostmarkMessage): Promise<SendStatus>;
-        send(message: PostmarkMessage, callback: PostmarkCallback<SendStatus>): undefined;
+        send(
+            message: PostmarkMessage,
+            callback: PostmarkCallback<SendStatus>
+        ): undefined;
 
-        sendEmailWithTemplate(message: PostmarkMessageWithTemplate): Promise<SendStatus>;
-        sendEmailWithTemplate(message: PostmarkMessageWithTemplate, 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;
+        batch(
+            message: PostmarkMessage[],
+            callback: PostmarkCallback<SendStatus[]>
+        ): undefined;
 
         sendEmail(message: PostmarkMessage): Promise<SendStatus>;
-        sendEmail(message: PostmarkMessage, callback: PostmarkCallback<SendStatus>): undefined;
+        sendEmail(
+            message: PostmarkMessage,
+            callback: PostmarkCallback<SendStatus>
+        ): undefined;
 
         sendEmailBatch(message: PostmarkMessage[]): Promise<SendStatus[]>;
-        sendEmailBatch(message: PostmarkMessage[], callback: PostmarkCallback<SendStatus[]>): undefined;
+        sendEmailBatch(
+            message: PostmarkMessage[],
+            callback: PostmarkCallback<SendStatus[]>
+        ): undefined;
 
         // stats
         getDeliveryStatistics(): Promise<DeliveryStats>;
-        getDeliveryStatistics(callback: PostmarkCallback<DeliveryStats>): undefined;
+        getDeliveryStatistics(
+            callback: PostmarkCallback<DeliveryStats>
+        ): undefined;
 
         // bounces
         getBounces(filter: BounceFilter): Promise<BouncesResult>;
-        getBounces(filter: BounceFilter, callback?: PostmarkCallback<BouncesResult>): undefined;
+        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;
+        getBounceDump(
+            id: number,
+            callback?: PostmarkCallback<BounceDump>
+        ): undefined;
 
         activateBounce(id: number): Promise<ActivatedBounceResult>;
-        activateBounce(id: number, callback?: PostmarkCallback<ActivatedBounceResult>): undefined;
+        activateBounce(
+            id: number,
+            callback?: PostmarkCallback<ActivatedBounceResult>
+        ): undefined;
 
         getBounceTags(): Promise<string[]>;
         getBounceTags(callback?: PostmarkCallback<string[]>): undefined;
@@ -148,54 +176,112 @@ declare namespace Postmark {
         getServer(callback?: PostmarkCallback<Server>): undefined;
 
         editServer(server: Partial<Server>): Promise<Server>;
-        editServer(server: Partial<Server>, callback?: PostmarkCallback<Server>): undefined;
+        editServer(
+            server: Partial<Server>,
+            callback?: PostmarkCallback<Server>
+        ): undefined;
 
         // message info
-        getOutboundMessages(filter: OutboundMessageFilter): Promise<OutboundMessagesResult>;
-        getOutboundMessages(filter: OutboundMessageFilter, callback?: PostmarkCallback<OutboundMessagesResult>): undefined;
+        getOutboundMessages(
+            filter: OutboundMessageFilter
+        ): Promise<OutboundMessagesResult>;
+        getOutboundMessages(
+            filter: OutboundMessageFilter,
+            callback?: PostmarkCallback<OutboundMessagesResult>
+        ): undefined;
 
         getOutboundMessageDetails(id: number): Promise<OutboundMessage>;
-        getOutboundMessageDetails(id: number, callback?: PostmarkCallback<OutboundMessage>): undefined;
+        getOutboundMessageDetails(
+            id: number,
+            callback?: PostmarkCallback<OutboundMessage>
+        ): undefined;
 
         getMessageOpens(filter: OpenMessageFilter): Promise<MessageOpensResult>;
-        getMessageOpens(filter: OpenMessageFilter, callback?: PostmarkCallback<MessageOpensResult>): undefined;
+        getMessageOpens(
+            filter: OpenMessageFilter,
+            callback?: PostmarkCallback<MessageOpensResult>
+        ): undefined;
 
-        getMessageOpensForSingleMessage(id: number, filter: Filter): Promise<MessageOpensResult>;
-        getMessageOpensForSingleMessage(id: number, filter: Filter, 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;
+        getInboundMessages(
+            filter: InboundMessageFilter
+        ): Promise<InboundMessagesResult>;
+        getInboundMessages(
+            filter: InboundMessageFilter,
+            callback?: PostmarkCallback<InboundMessagesResult>
+        ): undefined;
 
         getInboundMessageDetails(id: number): Promise<InboundMessage>;
-        getInboundMessageDetails(id: number, callback?: PostmarkCallback<InboundMessage>): undefined;
+        getInboundMessageDetails(
+            id: number,
+            callback?: PostmarkCallback<InboundMessage>
+        ): undefined;
 
         bypassBlockedInboundMessage(id: number): Promise<GenericResult>;
-        bypassBlockedInboundMessage(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+        bypassBlockedInboundMessage(
+            id: number,
+            callback?: PostmarkCallback<GenericResult>
+        ): undefined;
 
         getOuboundOverview(filter: BaseFilter): Promise<OutboundOverview>;
-        getOuboundOverview(filter: BaseFilter, callback?: PostmarkCallback<OutboundOverview>): undefined;
+        getOuboundOverview(
+            filter: BaseFilter,
+            callback?: PostmarkCallback<OutboundOverview>
+        ): undefined;
 
         retryInboundHookForMessage(id: number): Promise<GenericResult>;
-        retryInboundHookForMessage(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+        retryInboundHookForMessage(
+            id: number,
+            callback?: PostmarkCallback<GenericResult>
+        ): undefined;
 
         // templates
         getTemplate(id: number): Promise<Template>;
-        getTemplate(id: number, callback?: PostmarkCallback<Template>): undefined;
+        getTemplate(
+            id: number,
+            callback?: PostmarkCallback<Template>
+        ): undefined;
 
         createTemplate(template: Partial<Template>): Promise<TemplateBase>;
-        createTemplate(template: Partial<Template>, callback?: PostmarkCallback<TemplateBase>): undefined;
+        createTemplate(
+            template: Partial<Template>,
+            callback?: PostmarkCallback<TemplateBase>
+        ): undefined;
 
         editTemplate(template: Partial<Template>): Promise<TemplateBase>;
-        editTemplate(template: Partial<Template>, callback?: PostmarkCallback<TemplateBase>): undefined;
+        editTemplate(
+            template: Partial<Template>,
+            callback?: PostmarkCallback<TemplateBase>
+        ): undefined;
 
         getTemplates(filter: Filter): Promise<TemplatesResult>;
-        getTemplates(filter: Filter, callback?: PostmarkCallback<TemplatesResult>): undefined;
+        getTemplates(
+            filter: Filter,
+            callback?: PostmarkCallback<TemplatesResult>
+        ): undefined;
 
         deleteTemplate(id: number): Promise<GenericResult>;
-        deleteTemplate(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+        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;
+        validateTemplate<T extends object>(
+            templateObject: TemplateValidator<T>
+        ): Promise<TemplateValidationResult<T>>;
+        validateTemplate<T extends object>(
+            templateObject: TemplateValidator<T>,
+            callback?: PostmarkCallback<TemplateValidationResult<T>>
+        ): undefined;
     }
 
     interface CreateSignature extends UpdateSignature {
@@ -227,71 +313,130 @@ declare namespace Postmark {
     class AdminClient {
         constructor(apiKey: string, options: Partial<Options>);
         listSenderSignatures(query: Filter): Promise<SenderSignaturesResults>;
-        listSenderSignatures(query: Filter, callback?: PostmarkCallback<SenderSignaturesResults>): undefined;
+        listSenderSignatures(
+            query: Filter,
+            callback?: PostmarkCallback<SenderSignaturesResults>
+        ): undefined;
 
-        createSenderSignature(options: CreateSignature): Promise<SenderSignature>;
-        createSenderSignature(options: CreateSignature, callback?: PostmarkCallback<SenderSignature>): 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;
+        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;
+        deleteSenderSignature(
+            id: number,
+            callback?: PostmarkCallback<GenericResult>
+        ): undefined;
 
         resendSenderSignatureConfirmation(id: number): Promise<GenericResult>;
-        resendSenderSignatureConfirmation(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+        resendSenderSignatureConfirmation(
+            id: number,
+            callback?: PostmarkCallback<GenericResult>
+        ): undefined;
 
         verifySenderSignatureSPF(id: number): Promise<SenderSignature>;
-        verifySenderSignatureSPF(id: number, callback?: PostmarkCallback<SenderSignature>): undefined;
+        verifySenderSignatureSPF(
+            id: number,
+            callback?: PostmarkCallback<SenderSignature>
+        ): undefined;
 
         requestNewDKIMForSenderSignature(id: number): Promise<GenericResult>;
-        requestNewDKIMForSenderSignature(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+        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;
+        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;
+        editServer(
+            id: number,
+            options: Partial<CreateServer>,
+            callback?: PostmarkCallback<Server>
+        ): undefined;
 
         deleteServer(id: number): Promise<GenericResult>;
-        deleteServer(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+        deleteServer(
+            id: number,
+            callback?: PostmarkCallback<GenericResult>
+        ): undefined;
 
         listServers(query: ServerFilter): Promise<ServersResult>;
-        listServers(query: ServerFilter, callback?: PostmarkCallback<ServersResult>): undefined;
+        listServers(
+            query: ServerFilter,
+            callback?: PostmarkCallback<ServersResult>
+        ): undefined;
 
         // domains
         listDomains(query: Filter): Promise<DomainsResult>;
-        listDomains(query: Filter, callback?: PostmarkCallback<DomainsResult>): undefined;
+        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;
+        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;
+        editDomain(
+            id: number,
+            options: Partial<CreateDomain>,
+            callback?: PostmarkCallback<Domain>
+        ): undefined;
 
         deleteDomain(id: number): Promise<GenericResult>;
-        deleteDomain(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
+        deleteDomain(
+            id: number,
+            callback?: PostmarkCallback<GenericResult>
+        ): undefined;
 
         verifyDomainSPF(id: number): Promise<SenderSignature>;
-        verifyDomainSPF(id: number, callback?: PostmarkCallback<SenderSignature>): undefined;
+        verifyDomainSPF(
+            id: number,
+            callback?: PostmarkCallback<SenderSignature>
+        ): undefined;
 
         rotateDKIMForDomain(id: number): Promise<RotateDKIMResult>;
-        rotateDKIMForDomain(id: number, callback?: PostmarkCallback<RotateDKIMResult>): undefined;
+        rotateDKIMForDomain(
+            id: number,
+            callback?: PostmarkCallback<RotateDKIMResult>
+        ): undefined;
     }
 
     interface ClientClass {
-        new(serverKey: string, options: Partial<Options>): Client;
+        new (serverKey: string, options: Partial<Options>): Client;
     }
 
     interface AdminClientClass {
-        new(apiKey: string, options: Partial<Options>): AdminClient;
+        new (apiKey: string, options: Partial<Options>): AdminClient;
     }
 
     interface Postmark {
@@ -637,8 +782,7 @@ declare namespace Postmark {
         ReturnPathDomainVerified: boolean;
     }
 
-    interface Domain extends DomainBase, VerificationDetails {
-    }
+    interface Domain extends DomainBase, VerificationDetails {}
 
     interface RotateDKIMResult extends DKIMKey {
         Name: string;
@@ -666,3 +810,10 @@ declare namespace Postmark {
         WithReadTimeRecorded: number;
     }
 }
+
+declare function Postmark(
+    apiKey: string,
+    options: Partial<Postmark.Options>
+): Postmark.Client;
+
+export = Postmark;
diff --git a/types/postmark/postmark-tests.ts b/types/postmark/postmark-tests.ts
index f18bff2ef6..292346aab3 100644
--- a/types/postmark/postmark-tests.ts
+++ b/types/postmark/postmark-tests.ts
@@ -1,20 +1,22 @@
-import postmark = require('postmark');
+import * as postmark from "postmark";
 
-declare var options: typeof postmark.defaults;
-const message = { To: 'me', From: 'you' };
-const templateMessage = {...message, TemplateId: '1'};
+declare const options: typeof postmark.defaults;
+const message = { To: "me", From: "you" };
+const templateMessage = { ...message, TemplateId: "1" };
 const filter = { offset: 0 };
-const editSender = { Color: 'black' };
+const editSender = { Color: "black" };
 const templateValidator = {
-  Subject: '123',
-  HtmlBody: '123345',
-  TextBody: '123535',
+    Subject: "123",
+    HtmlBody: "123345",
+    TextBody: "123535"
 };
 
+declare const error: postmark.PostmarkError;
+
 declare function callback(err: any, data: any): undefined;
 
-const client = new postmark.Client('124345', options);
-const adminClient = new postmark.AdminClient('1123235', options);
+const client = new postmark.Client("124345", options);
+const adminClient = new postmark.AdminClient("1123235", options);
 
 client.send(message, callback);
 client.sendEmailWithTemplate(templateMessage, callback);
@@ -40,66 +42,68 @@ 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(() => { });
+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, {Name: '123'}, callback);
+adminClient.createSenderSignature({ FromEmail: "", Name: "" }, 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, {Name: 'black'}, callback);
+adminClient.createServer({ Name: "123" }, callback);
+adminClient.editServer(0, { Name: "black" }, callback);
 adminClient.deleteServer(0, callback);
 adminClient.listServers(filter, callback);
 adminClient.listDomains(filter, callback);
 adminClient.getDomain(0, callback);
-adminClient.createDomain({Name: '1234'}, callback);
-adminClient.editDomain(0, {ReturnPathDomain: '/'}, callback);
+adminClient.createDomain({ Name: "1234" }, callback);
+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(() => { });
+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(() => {});
diff --git a/types/postmark/tsconfig.json b/types/postmark/tsconfig.json
index 86df19a17f..4406f866ae 100644
--- a/types/postmark/tsconfig.json
+++ b/types/postmark/tsconfig.json
@@ -1,23 +1,16 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "es6"
-        ],
+        "lib": ["es6"],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
-        "strictFunctionTypes": true,
         "baseUrl": "../",
-        "typeRoots": [
-            "../"
-        ],
+        "typeRoots": ["../"],
         "types": [],
         "noEmit": true,
-        "forceConsistentCasingInFileNames": true
+        "forceConsistentCasingInFileNames": true,
+        "strictFunctionTypes": true
     },
-    "files": [
-        "index.d.ts",
-        "postmark-tests.ts"
-    ]
-}
\ No newline at end of file
+    "files": ["index.d.ts", "postmark-tests.ts"]
+}
diff --git a/types/postmark/tslint.json b/types/postmark/tslint.json
index 71ee04c4e1..3db14f85ea 100644
--- a/types/postmark/tslint.json
+++ b/types/postmark/tslint.json
@@ -1,6 +1 @@
-{
-    "extends": "dtslint/dt.json",
-    "rules": {
-        "no-unnecessary-generics": false
-    }
-}
+{ "extends": "dtslint/dt.json" }

From 15baaf1af99c1f737651f246b445cc3c79592ee2 Mon Sep 17 00:00:00 2001
From: Jinesh Shah <jineshshah36@gmail.com>
Date: Fri, 7 Sep 2018 13:07:19 -0400
Subject: [PATCH 2/4] first commit

---
 types/uploadcare/index.d.ts          | 68 ++++++++++++++++++++++++++++
 types/uploadcare/tsconfig.json       | 16 +++++++
 types/uploadcare/tslint.json         |  1 +
 types/uploadcare/uploadcare-tests.ts |  7 +++
 4 files changed, 92 insertions(+)
 create mode 100644 types/uploadcare/index.d.ts
 create mode 100644 types/uploadcare/tsconfig.json
 create mode 100644 types/uploadcare/tslint.json
 create mode 100644 types/uploadcare/uploadcare-tests.ts

diff --git a/types/uploadcare/index.d.ts b/types/uploadcare/index.d.ts
new file mode 100644
index 0000000000..3b3e4e1b09
--- /dev/null
+++ b/types/uploadcare/index.d.ts
@@ -0,0 +1,68 @@
+// Type definitions for uploadcare 0.4
+// Project: https://github.com/rexmorgan/uploadcare-node
+// Definitions by: Jinesh Shah <https://github.com/jineshshah36>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+import { ReadStream } from "fs";
+
+declare namespace Uploadcare {
+    interface File {
+        original_file_url: string;
+        image_info: ImageInfo;
+        mime_type: string;
+        is_ready: boolean;
+        url: string;
+        uuid: string;
+        original_filename: string;
+        datetime_uploaded: string;
+        size: number;
+        is_image: boolean;
+        datetime_stored: string;
+        datetime_removed: string | null;
+    }
+
+    interface ImageInfo {
+        orientation: null;
+        sequence: boolean;
+        format: string;
+        height: number;
+        width: number;
+        geo_location: null;
+        datetime_original: null;
+        dpi: number[];
+    }
+
+    interface Instance {
+        file: {
+            upload: (
+                readStream: ReadStream,
+                options: { store?: boolean },
+                callback: (err: Error, res: { file: string }) => void
+            ) => void;
+            fromUrl: (
+                url: string,
+                options: { store?: boolean },
+                callback: (err: Error, res: File) => void
+            ) => void;
+        };
+        files: {
+            store: (
+                uuid: string,
+                callback: (err: Error, res: File) => void
+            ) => void;
+            remove: (
+                uuid: string,
+                callback: (err: Error, res: File) => void
+            ) => void;
+        };
+    }
+}
+
+declare function Uploadcare(
+    publicKey: string,
+    privateKey: string
+): Uploadcare.Instance;
+
+export = Uploadcare;
diff --git a/types/uploadcare/tsconfig.json b/types/uploadcare/tsconfig.json
new file mode 100644
index 0000000000..44810d6b42
--- /dev/null
+++ b/types/uploadcare/tsconfig.json
@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": ["es6"],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": ["../"],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true,
+        "strictFunctionTypes": true
+    },
+    "files": ["index.d.ts", "uploadcare-tests.ts"]
+}
diff --git a/types/uploadcare/tslint.json b/types/uploadcare/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/uploadcare/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/uploadcare/uploadcare-tests.ts b/types/uploadcare/uploadcare-tests.ts
new file mode 100644
index 0000000000..295a470691
--- /dev/null
+++ b/types/uploadcare/uploadcare-tests.ts
@@ -0,0 +1,7 @@
+import * as Uploadcare from "uploadcare";
+
+const uploadcare = Uploadcare("", "");
+
+uploadcare.file.fromUrl("", {}, (err, res) => {
+    const file: Uploadcare.File = res;
+});

From 0468504e111f7f5622a55f642244a0e4588de196 Mon Sep 17 00:00:00 2001
From: Jinesh Shah <jineshshah36@gmail.com>
Date: Fri, 7 Sep 2018 13:11:00 -0400
Subject: [PATCH 3/4] reverted postmark changes

---
 types/postmark/index.d.ts        | 267 +++++++------------------------
 types/postmark/postmark-tests.ts | 120 +++++++-------
 types/postmark/tsconfig.json     |  19 ++-
 types/postmark/tslint.json       |   7 +-
 4 files changed, 135 insertions(+), 278 deletions(-)

diff --git a/types/postmark/index.d.ts b/types/postmark/index.d.ts
index b2b7ac0cfc..24810299a7 100644
--- a/types/postmark/index.d.ts
+++ b/types/postmark/index.d.ts
@@ -1,10 +1,12 @@
 // Type definitions for postmark 1.4
 // Project: http://wildbit.github.io/postmark.js
-// Definitions by:  Ben Bayard <https://github.com/benbayard>
-//                  Jinesh Shah <https://github.com/jineshshah36>
+// Definitions by: Ben Bayard <https://github.com/benbayard>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.4
 
+export = postmark;
+
+declare const postmark: Postmark.Postmark;
 declare namespace Postmark {
     const defaults: Options;
 
@@ -85,9 +87,7 @@ declare namespace Postmark {
         InlineCssForHtmlTestRender?: boolean;
     }
 
-    type PostmarkCallback<T extends object = any> =
-        | ((e: PostmarkError, ret: T) => undefined)
-        | undefined;
+    type PostmarkCallback<T extends object = any> = ((e: PostmarkError, ret: T) => undefined) | undefined;
 
     interface SimpleOptions {
         ssl: boolean;
@@ -109,64 +109,36 @@ declare namespace Postmark {
         constructor(serverKey: string, options?: Partial<Options>);
 
         send(message: PostmarkMessage): Promise<SendStatus>;
-        send(
-            message: PostmarkMessage,
-            callback: PostmarkCallback<SendStatus>
-        ): undefined;
+        send(message: PostmarkMessage, callback: PostmarkCallback<SendStatus>): undefined;
 
-        sendEmailWithTemplate(
-            message: PostmarkMessageWithTemplate
-        ): Promise<SendStatus>;
-        sendEmailWithTemplate(
-            message: PostmarkMessageWithTemplate,
-            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;
+        batch(message: PostmarkMessage[], callback: PostmarkCallback<SendStatus[]>): undefined;
 
         sendEmail(message: PostmarkMessage): Promise<SendStatus>;
-        sendEmail(
-            message: PostmarkMessage,
-            callback: PostmarkCallback<SendStatus>
-        ): undefined;
+        sendEmail(message: PostmarkMessage, callback: PostmarkCallback<SendStatus>): undefined;
 
         sendEmailBatch(message: PostmarkMessage[]): Promise<SendStatus[]>;
-        sendEmailBatch(
-            message: PostmarkMessage[],
-            callback: PostmarkCallback<SendStatus[]>
-        ): undefined;
+        sendEmailBatch(message: PostmarkMessage[], callback: PostmarkCallback<SendStatus[]>): undefined;
 
         // stats
         getDeliveryStatistics(): Promise<DeliveryStats>;
-        getDeliveryStatistics(
-            callback: PostmarkCallback<DeliveryStats>
-        ): undefined;
+        getDeliveryStatistics(callback: PostmarkCallback<DeliveryStats>): undefined;
 
         // bounces
         getBounces(filter: BounceFilter): Promise<BouncesResult>;
-        getBounces(
-            filter: BounceFilter,
-            callback?: PostmarkCallback<BouncesResult>
-        ): undefined;
+        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;
+        getBounceDump(id: number, callback?: PostmarkCallback<BounceDump>): undefined;
 
         activateBounce(id: number): Promise<ActivatedBounceResult>;
-        activateBounce(
-            id: number,
-            callback?: PostmarkCallback<ActivatedBounceResult>
-        ): undefined;
+        activateBounce(id: number, callback?: PostmarkCallback<ActivatedBounceResult>): undefined;
 
         getBounceTags(): Promise<string[]>;
         getBounceTags(callback?: PostmarkCallback<string[]>): undefined;
@@ -176,112 +148,54 @@ declare namespace Postmark {
         getServer(callback?: PostmarkCallback<Server>): undefined;
 
         editServer(server: Partial<Server>): Promise<Server>;
-        editServer(
-            server: Partial<Server>,
-            callback?: PostmarkCallback<Server>
-        ): undefined;
+        editServer(server: Partial<Server>, callback?: PostmarkCallback<Server>): undefined;
 
         // message info
-        getOutboundMessages(
-            filter: OutboundMessageFilter
-        ): Promise<OutboundMessagesResult>;
-        getOutboundMessages(
-            filter: OutboundMessageFilter,
-            callback?: PostmarkCallback<OutboundMessagesResult>
-        ): undefined;
+        getOutboundMessages(filter: OutboundMessageFilter): Promise<OutboundMessagesResult>;
+        getOutboundMessages(filter: OutboundMessageFilter, callback?: PostmarkCallback<OutboundMessagesResult>): undefined;
 
         getOutboundMessageDetails(id: number): Promise<OutboundMessage>;
-        getOutboundMessageDetails(
-            id: number,
-            callback?: PostmarkCallback<OutboundMessage>
-        ): undefined;
+        getOutboundMessageDetails(id: number, callback?: PostmarkCallback<OutboundMessage>): undefined;
 
         getMessageOpens(filter: OpenMessageFilter): Promise<MessageOpensResult>;
-        getMessageOpens(
-            filter: OpenMessageFilter,
-            callback?: PostmarkCallback<MessageOpensResult>
-        ): undefined;
+        getMessageOpens(filter: OpenMessageFilter, callback?: PostmarkCallback<MessageOpensResult>): undefined;
 
-        getMessageOpensForSingleMessage(
-            id: number,
-            filter: Filter
-        ): Promise<MessageOpensResult>;
-        getMessageOpensForSingleMessage(
-            id: number,
-            filter: Filter,
-            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;
+        getInboundMessages(filter: InboundMessageFilter): Promise<InboundMessagesResult>;
+        getInboundMessages(filter: InboundMessageFilter, callback?: PostmarkCallback<InboundMessagesResult>): undefined;
 
         getInboundMessageDetails(id: number): Promise<InboundMessage>;
-        getInboundMessageDetails(
-            id: number,
-            callback?: PostmarkCallback<InboundMessage>
-        ): undefined;
+        getInboundMessageDetails(id: number, callback?: PostmarkCallback<InboundMessage>): undefined;
 
         bypassBlockedInboundMessage(id: number): Promise<GenericResult>;
-        bypassBlockedInboundMessage(
-            id: number,
-            callback?: PostmarkCallback<GenericResult>
-        ): undefined;
+        bypassBlockedInboundMessage(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
 
         getOuboundOverview(filter: BaseFilter): Promise<OutboundOverview>;
-        getOuboundOverview(
-            filter: BaseFilter,
-            callback?: PostmarkCallback<OutboundOverview>
-        ): undefined;
+        getOuboundOverview(filter: BaseFilter, callback?: PostmarkCallback<OutboundOverview>): undefined;
 
         retryInboundHookForMessage(id: number): Promise<GenericResult>;
-        retryInboundHookForMessage(
-            id: number,
-            callback?: PostmarkCallback<GenericResult>
-        ): undefined;
+        retryInboundHookForMessage(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
 
         // templates
         getTemplate(id: number): Promise<Template>;
-        getTemplate(
-            id: number,
-            callback?: PostmarkCallback<Template>
-        ): undefined;
+        getTemplate(id: number, callback?: PostmarkCallback<Template>): undefined;
 
         createTemplate(template: Partial<Template>): Promise<TemplateBase>;
-        createTemplate(
-            template: Partial<Template>,
-            callback?: PostmarkCallback<TemplateBase>
-        ): undefined;
+        createTemplate(template: Partial<Template>, callback?: PostmarkCallback<TemplateBase>): undefined;
 
         editTemplate(template: Partial<Template>): Promise<TemplateBase>;
-        editTemplate(
-            template: Partial<Template>,
-            callback?: PostmarkCallback<TemplateBase>
-        ): undefined;
+        editTemplate(template: Partial<Template>, callback?: PostmarkCallback<TemplateBase>): undefined;
 
         getTemplates(filter: Filter): Promise<TemplatesResult>;
-        getTemplates(
-            filter: Filter,
-            callback?: PostmarkCallback<TemplatesResult>
-        ): undefined;
+        getTemplates(filter: Filter, callback?: PostmarkCallback<TemplatesResult>): undefined;
 
         deleteTemplate(id: number): Promise<GenericResult>;
-        deleteTemplate(
-            id: number,
-            callback?: PostmarkCallback<GenericResult>
-        ): undefined;
+        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;
+        validateTemplate<T extends object>(templateObject: TemplateValidator<T>): Promise<TemplateValidationResult<T>>;
+        validateTemplate<T extends object>(templateObject: TemplateValidator<T>, callback?: PostmarkCallback<TemplateValidationResult<T>>): undefined;
     }
 
     interface CreateSignature extends UpdateSignature {
@@ -313,130 +227,71 @@ declare namespace Postmark {
     class AdminClient {
         constructor(apiKey: string, options: Partial<Options>);
         listSenderSignatures(query: Filter): Promise<SenderSignaturesResults>;
-        listSenderSignatures(
-            query: Filter,
-            callback?: PostmarkCallback<SenderSignaturesResults>
-        ): undefined;
+        listSenderSignatures(query: Filter, callback?: PostmarkCallback<SenderSignaturesResults>): undefined;
 
-        createSenderSignature(
-            options: CreateSignature
-        ): Promise<SenderSignature>;
-        createSenderSignature(
-            options: CreateSignature,
-            callback?: PostmarkCallback<SenderSignature>
-        ): 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;
+        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;
+        deleteSenderSignature(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
 
         resendSenderSignatureConfirmation(id: number): Promise<GenericResult>;
-        resendSenderSignatureConfirmation(
-            id: number,
-            callback?: PostmarkCallback<GenericResult>
-        ): undefined;
+        resendSenderSignatureConfirmation(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
 
         verifySenderSignatureSPF(id: number): Promise<SenderSignature>;
-        verifySenderSignatureSPF(
-            id: number,
-            callback?: PostmarkCallback<SenderSignature>
-        ): undefined;
+        verifySenderSignatureSPF(id: number, callback?: PostmarkCallback<SenderSignature>): undefined;
 
         requestNewDKIMForSenderSignature(id: number): Promise<GenericResult>;
-        requestNewDKIMForSenderSignature(
-            id: number,
-            callback?: PostmarkCallback<GenericResult>
-        ): undefined;
+        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;
+        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;
+        editServer(id: number, options: Partial<CreateServer>, callback?: PostmarkCallback<Server>): undefined;
 
         deleteServer(id: number): Promise<GenericResult>;
-        deleteServer(
-            id: number,
-            callback?: PostmarkCallback<GenericResult>
-        ): undefined;
+        deleteServer(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
 
         listServers(query: ServerFilter): Promise<ServersResult>;
-        listServers(
-            query: ServerFilter,
-            callback?: PostmarkCallback<ServersResult>
-        ): undefined;
+        listServers(query: ServerFilter, callback?: PostmarkCallback<ServersResult>): undefined;
 
         // domains
         listDomains(query: Filter): Promise<DomainsResult>;
-        listDomains(
-            query: Filter,
-            callback?: PostmarkCallback<DomainsResult>
-        ): undefined;
+        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;
+        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;
+        editDomain(id: number, options: Partial<CreateDomain>, callback?: PostmarkCallback<Domain>): undefined;
 
         deleteDomain(id: number): Promise<GenericResult>;
-        deleteDomain(
-            id: number,
-            callback?: PostmarkCallback<GenericResult>
-        ): undefined;
+        deleteDomain(id: number, callback?: PostmarkCallback<GenericResult>): undefined;
 
         verifyDomainSPF(id: number): Promise<SenderSignature>;
-        verifyDomainSPF(
-            id: number,
-            callback?: PostmarkCallback<SenderSignature>
-        ): undefined;
+        verifyDomainSPF(id: number, callback?: PostmarkCallback<SenderSignature>): undefined;
 
         rotateDKIMForDomain(id: number): Promise<RotateDKIMResult>;
-        rotateDKIMForDomain(
-            id: number,
-            callback?: PostmarkCallback<RotateDKIMResult>
-        ): undefined;
+        rotateDKIMForDomain(id: number, callback?: PostmarkCallback<RotateDKIMResult>): undefined;
     }
 
     interface ClientClass {
-        new (serverKey: string, options: Partial<Options>): Client;
+        new(serverKey: string, options: Partial<Options>): Client;
     }
 
     interface AdminClientClass {
-        new (apiKey: string, options: Partial<Options>): AdminClient;
+        new(apiKey: string, options: Partial<Options>): AdminClient;
     }
 
     interface Postmark {
@@ -782,7 +637,8 @@ declare namespace Postmark {
         ReturnPathDomainVerified: boolean;
     }
 
-    interface Domain extends DomainBase, VerificationDetails {}
+    interface Domain extends DomainBase, VerificationDetails {
+    }
 
     interface RotateDKIMResult extends DKIMKey {
         Name: string;
@@ -810,10 +666,3 @@ declare namespace Postmark {
         WithReadTimeRecorded: number;
     }
 }
-
-declare function Postmark(
-    apiKey: string,
-    options: Partial<Postmark.Options>
-): Postmark.Client;
-
-export = Postmark;
diff --git a/types/postmark/postmark-tests.ts b/types/postmark/postmark-tests.ts
index 292346aab3..f18bff2ef6 100644
--- a/types/postmark/postmark-tests.ts
+++ b/types/postmark/postmark-tests.ts
@@ -1,22 +1,20 @@
-import * as postmark from "postmark";
+import postmark = require('postmark');
 
-declare const options: typeof postmark.defaults;
-const message = { To: "me", From: "you" };
-const templateMessage = { ...message, TemplateId: "1" };
+declare var options: typeof postmark.defaults;
+const message = { To: 'me', From: 'you' };
+const templateMessage = {...message, TemplateId: '1'};
 const filter = { offset: 0 };
-const editSender = { Color: "black" };
+const editSender = { Color: 'black' };
 const templateValidator = {
-    Subject: "123",
-    HtmlBody: "123345",
-    TextBody: "123535"
+  Subject: '123',
+  HtmlBody: '123345',
+  TextBody: '123535',
 };
 
-declare const error: postmark.PostmarkError;
-
 declare function callback(err: any, data: any): undefined;
 
-const client = new postmark.Client("124345", options);
-const adminClient = new postmark.AdminClient("1123235", options);
+const client = new postmark.Client('124345', options);
+const adminClient = new postmark.AdminClient('1123235', options);
 
 client.send(message, callback);
 client.sendEmailWithTemplate(templateMessage, callback);
@@ -42,68 +40,66 @@ 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(() => {});
+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, { Name: "123" }, callback);
+adminClient.createSenderSignature({FromEmail: '', Name: ''}, 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, { Name: "black" }, callback);
+adminClient.createServer({Name: '123'}, callback);
+adminClient.editServer(0, {Name: 'black'}, callback);
 adminClient.deleteServer(0, callback);
 adminClient.listServers(filter, callback);
 adminClient.listDomains(filter, callback);
 adminClient.getDomain(0, callback);
-adminClient.createDomain({ Name: "1234" }, callback);
-adminClient.editDomain(0, { ReturnPathDomain: "/" }, callback);
+adminClient.createDomain({Name: '1234'}, callback);
+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(() => {});
+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(() => { });
diff --git a/types/postmark/tsconfig.json b/types/postmark/tsconfig.json
index 4406f866ae..86df19a17f 100644
--- a/types/postmark/tsconfig.json
+++ b/types/postmark/tsconfig.json
@@ -1,16 +1,23 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": ["es6"],
+        "lib": [
+            "es6"
+        ],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
+        "strictFunctionTypes": true,
         "baseUrl": "../",
-        "typeRoots": ["../"],
+        "typeRoots": [
+            "../"
+        ],
         "types": [],
         "noEmit": true,
-        "forceConsistentCasingInFileNames": true,
-        "strictFunctionTypes": true
+        "forceConsistentCasingInFileNames": true
     },
-    "files": ["index.d.ts", "postmark-tests.ts"]
-}
+    "files": [
+        "index.d.ts",
+        "postmark-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/types/postmark/tslint.json b/types/postmark/tslint.json
index 3db14f85ea..0ee527fa0f 100644
--- a/types/postmark/tslint.json
+++ b/types/postmark/tslint.json
@@ -1 +1,6 @@
-{ "extends": "dtslint/dt.json" }
+{
+  "extends": "dtslint/dt.json",
+  "rules": {
+      "no-unnecessary-generics": false
+  }
+}

From 9e7c5b8615b7d736c31c7ec4b9d72002389ba566 Mon Sep 17 00:00:00 2001
From: Jinesh Shah <jineshshah36@users.noreply.github.com>
Date: Fri, 7 Sep 2018 13:13:28 -0400
Subject: [PATCH 4/4] Update tslint.json

---
 types/postmark/tslint.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/types/postmark/tslint.json b/types/postmark/tslint.json
index 0ee527fa0f..71ee04c4e1 100644
--- a/types/postmark/tslint.json
+++ b/types/postmark/tslint.json
@@ -1,6 +1,6 @@
 {
-  "extends": "dtslint/dt.json",
-  "rules": {
-      "no-unnecessary-generics": false
-  }
+    "extends": "dtslint/dt.json",
+    "rules": {
+        "no-unnecessary-generics": false
+    }
 }