postmark: Provides its own types (#39495)

This commit is contained in:
Alexander T
2019-11-01 10:42:35 -07:00
committed by Jesse Trinity
parent 2c5f177ce7
commit 5ab0100370
5 changed files with 6 additions and 945 deletions
+6
View File
@@ -3210,6 +3210,12 @@
"sourceRepoURL": "https://github.com/sindresorhus/positive-zero",
"asOfVersion": "3.0.0"
},
{
"libraryName": "postmark",
"typingsPackageName": "postmark",
"sourceRepoURL": "http://wildbit.github.io/postmark.js",
"asOfVersion": "2.0.0"
},
{
"libraryName": "Prando",
"typingsPackageName": "prando",
-819
View File
@@ -1,819 +0,0 @@
// 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: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.4
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) => undefined)
| 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): 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 extends UpdateSignature {
FromEmail: 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: 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 {
new (serverKey: string, options: Partial<Options>): Client;
}
interface AdminClientClass {
new (apiKey: string, options: Partial<Options>): AdminClient;
}
interface Postmark {
(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;
}
}
declare function Postmark(
apiKey: string,
options: Partial<Postmark.Options>
): Postmark.Client;
export = Postmark;
-109
View File
@@ -1,109 +0,0 @@
import * as postmark from "postmark";
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 templateValidator = {
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);
client.send(message, callback);
client.sendEmailWithTemplate(templateMessage, callback);
client.batch([message, message], callback);
client.sendEmail(message, callback);
client.sendEmailBatch([message, message], callback);
client.getDeliveryStatistics(callback);
client.getBounces(filter, callback);
client.getBounce(1, callback);
client.getBounceDump(1, callback);
client.activateBounce(1, callback);
client.getBounceTags(callback);
client.getServer(callback);
client.editServer(editSender, callback);
client.getOutboundMessages(filter, callback);
client.getOutboundMessageDetails(1, callback);
client.getMessageOpens(filter, callback);
client.getMessageOpensForSingleMessage(1, filter, callback);
client.getInboundMessages(filter, callback);
client.getInboundMessageDetails(1, callback);
client.bypassBlockedInboundMessage(1, callback);
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, { 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.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.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(() => {});
-16
View File
@@ -1,16 +0,0 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": ["es6"],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": ["../"],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true,
"strictFunctionTypes": true
},
"files": ["index.d.ts", "postmark-tests.ts"]
}
-1
View File
@@ -1 +0,0 @@
{ "extends": "dtslint/dt.json" }