222

schangxiang@126.com

2025-06-13 6a8393408d8cefcea02b7a598967de8dc1e565c2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/// <reference types="node" />
 
import { EventEmitter } from 'events';
import * as stream from 'stream';
 
import { Transport, TransportOptions } from '..';
import * as shared from './shared';
 
import Mail = require('./mailer');
import MailMessage = require('./mailer/mail-message');
import MimeNode = require('./mime-node');
import SMTPConnection = require('./smtp-connection');
import XOAuth2 = require('./xoauth2');
 
declare namespace SMTPTransport {
    interface AuthenticationTypeCustom extends SMTPConnection.Credentials {
        type: 'CUSTOM';
        method: string;
    }
 
    interface AuthenticationTypeLogin {
        type: 'LOGIN';
        user: string;
        credentials: SMTPConnection.Credentials;
        method: string | false;
    }
 
    interface AuthenticationTypeOAuth2 {
        type: 'OAUTH2';
        user: string;
        oauth2: XOAuth2;
        method: 'XOAUTH2';
    }
 
    type AuthenticationType = AuthenticationTypeLogin | AuthenticationTypeOAuth2;
 
    interface MailOptions extends Mail.Options {
        auth?: SMTPConnection.AuthenticationType;
        dsn?: SMTPConnection.DSNOptions;
    }
 
    interface Options extends MailOptions, TransportOptions, SMTPConnection.Options {
        service?: string;
        getSocket?(options: Options, callback: (err: Error | null, socketOptions: any) => void): void; // TODO http.ClientRequest?
        url?: string;
    }
 
    interface SentMessageInfo {
        /** includes the envelope object for the message */
        envelope: MimeNode.Envelope;
        /** most transports should return the final Message-Id value used with this property */
        messageId: string;
    }
}
 
declare class SMTPTransport extends EventEmitter implements Transport {
    options: SMTPTransport.Options;
 
    mailer: Mail;
    logger: shared.Logger;
 
    name: string;
    version: string;
 
    auth: SMTPTransport.AuthenticationType;
 
    constructor(options: SMTPTransport.Options | string);
 
    /** Placeholder function for creating proxy sockets. This method immediatelly returns without a socket */
    getSocket(options: SMTPTransport.Options, callback: (err: Error | null, socketOptions: object) => void): void;
 
    getAuth(authOpts: SMTPConnection.AuthenticationTypeLogin | SMTPConnection.AuthenticationTypeOAuth2): SMTPTransport.AuthenticationType;
 
    /** Sends an e-mail using the selected settings */
    send(mail: MailMessage, callback: (err: Error | null, info: SMTPTransport.SentMessageInfo) => void): void;
 
    /** Verifies SMTP configuration */
    verify(callback: (err: Error | null, success: true) => void): void;
    verify(): Promise<true>;
 
    /** Releases resources */
    close(): void;
 
    addListener(event: 'close', listener: () => void): this;
    addListener(event: 'error', listener: (err: Error) => void): this;
 
    emit(event: 'close'): boolean;
    emit(event: 'error', error: Error): boolean;
 
    on(event: 'close', listener: () => void): this;
    on(event: 'error', listener: (err: Error) => void): this;
 
    once(event: 'close', listener: () => void): this;
    once(event: 'error', listener: (err: Error) => void): this;
 
    prependListener(event: 'close', listener: () => void): this;
    prependListener(event: 'error', listener: (err: Error) => void): this;
 
    prependOnceListener(event: 'close', listener: () => void): this;
    prependOnceListener(event: 'error', listener: (err: Error) => void): this;
 
    listeners(event: 'close'): Array<() => void>;
    listeners(event: 'error'): Array<(err: Error) => void>;
}
 
export = SMTPTransport;