
export declare interface Collection<E> {

}

export declare class WrappedList<OUT_T, IN_T> {
  constructor();
  constructor(list?: any, readOnly?: boolean);

  public add(element: OUT_T): boolean;
  public add(index: number, element: OUT_T): void;

  public insert(index: number, element: OUT_T): void;

  public get(index: number): OUT_T;

  public indexOf(o: any): number;
  public lastIndexOf(o: any): number;

  public remove(obj: any): boolean;
  public remove(index: number): OUT_T;

  public set(index: number, element: OUT_T): OUT_T;

  public clear(): void;
  public contains(o: any): boolean;
  public isEmpty(): boolean;

  public [Symbol.iterator](): Iterator<OUT_T>;

  public size(): number;

  public toArray(): OUT_T[];

}



export declare class WrappedMap<OUT_T, IN_T> extends Map<any, OUT_T> {
  public has(key: any): boolean;
  public set(key: any, value: OUT_T): this;
  public get size(): number;
  public keys(): IterableIterator<any>;

  public values(): IterableIterator<OUT_T>;

  public clear(): void;
  public containsKey(key: any): boolean;
  public containsValue(value: any): boolean;

  public get(key: any): OUT_T;
  public isEmpty(): boolean;
  public put(key: any, value: OUT_T): OUT_T;

  public remove(key: any): OUT_T



}

import * as events from 'events';
export interface ReadableStream {
    read(buffer: Uint8Array, offset: number, length: number): Promise<number>;
    readSync(buffer: Uint8Array, offset: number, length: number): number;
    available(): number;
    close(): void;
    mark(): void;
    reset(): void;
    markSupported(): boolean;
}
export interface WriteableStream {
    write(data: Uint8Array, offset: number, length: number): Promise<void>;
    writeSync(data: Uint8Array, offset: number, length: number): void;
    close(): void;
    closeSync(): void;
}
type CCertExtension=any;
export declare class CertExtension {
    private obj;
    constructor(obj: CCertExtension);
    constructor(OID: string, value: Uint8Array, critical: boolean);
    unwrap(): CCertExtension;
    getCritical(): boolean;
    getOID(): string;
    getValue(): string;
    getValueB(): Uint8Array;
    clone(): any;
}
export declare class CertExtensionList extends WrappedList<CertExtension, CCertExtension> {
    constructor(list: any, readOnly: boolean);
    protected_wrap(o: CCertExtension): CertExtension;
    protected_unwrap(o: CertExtension): CCertExtension;
    item(index: number): CertExtension;
    addAll(c: Collection<CertExtension>): boolean;
    addAll(index: number, c: Collection<CertExtension>): boolean;
    addRange(c: Collection<CertExtension>): void;
    size(): number;
    clone(): any;
}
type CCertificate=any;
export declare enum CertStoreTypes {
    cstUser = 0,
    cstMachine = 1,
    cstPFXFile = 2,
    cstPFXBlob = 3,
    cstJKSFile = 4,
    cstJKSBlob = 5,
    cstPEMKeyFile = 6,
    cstPEMKeyBlob = 7,
    cstPublicKeyFile = 8,
    cstPublicKeyBlob = 9,
    cstSSHPublicKeyBlob = 10,
    cstP7BFile = 11,
    cstP7BBlob = 12,
    cstSSHPublicKeyFile = 13,
    cstPPKFile = 14,
    cstPPKBlob = 15,
    cstXMLFile = 16,
    cstXMLBlob = 17,
    cstJWKFile = 18,
    cstJWKBlob = 19,
    cstSecurityKey = 20,
    cstBCFKSFile = 21,
    cstBCFKSBlob = 22,
    cstPKCS11 = 23,
    cstAuto = 99
}
export declare class Certificate {
    private obj;
    constructor(obj: CCertificate);
    constructor();
    constructor(certificateFile: string);
    constructor(encoded: Uint8Array);
    constructor(storeType: CertStoreTypes, store: string, storePassword: string, subject: string);
    constructor(storeType: CertStoreTypes, store: string, storePassword: string, subject: string, configurationString: string);
    constructor(storeType: CertStoreTypes, store: string, storePassword: string, encoded: Uint8Array);
    constructor(storeType: CertStoreTypes, store: Uint8Array, storePassword: string, subject: string);
    constructor(storeType: CertStoreTypes, store: Uint8Array, storePassword: string, subject: string, configurationString: string);
    constructor(storeType: CertStoreTypes, store: Uint8Array, storePassword: string, encoded: Uint8Array);
    unwrap(): CCertificate;
    getEffectiveDate(): string;
    getExpirationDate(): string;
    getExtendedKeyUsage(): string;
    getFingerprint(): string;
    getFingerprintSHA1(): string;
    getFingerprintSHA256(): string;
    getIssuer(): string;
    getKeyPassword(): string;
    setKeyPassword(keyPassword: string): void;
    getPrivateKey(): string;
    getPrivateKeyAvailable(): boolean;
    getPrivateKeyContainer(): string;
    getPublicKey(): string;
    getPublicKeyAlgorithm(): string;
    getPublicKeyLength(): number;
    getSerialNumber(): string;
    getSignatureAlgorithm(): string;
    getStore(): string;
    getStoreB(): Uint8Array;
    setStore(store: Uint8Array | string): void;
    setStore(store: Uint8Array, offset: number, length: number): void;
    getStorePassword(): string;
    setStorePassword(storePassword: string): void;
    getStoreType(): CertStoreTypes;
    setStoreType(storeType: CertStoreTypes): void;
    getSubjectAltNames(): string;
    getThumbprintMD5(): string;
    getThumbprintSHA1(): string;
    getThumbprintSHA256(): string;
    getUsage(): string;
    getUsageFlags(): number;
    getVersion(): string;
    getSubject(): string;
    setSubject(subject: string): void;
    getEncoded(): string;
    getEncodedB(): Uint8Array;
    setEncoded(encoded: Uint8Array | string): void;
    setEncoded(encoded: Uint8Array, offset: number, length: number): void;
    clone(): any;
}
export declare class CertificateList extends WrappedList<Certificate, CCertificate> {
    constructor(list: any, readOnly: boolean);
    protected_wrap(o: CCertificate): Certificate;
    protected_unwrap(o: Certificate): CCertificate;
    item(index: number): Certificate;
    addAll(c: Collection<Certificate>): boolean;
    addAll(index: number, c: Collection<Certificate>): boolean;
    addRange(c: Collection<Certificate>): void;
    size(): number;
    clone(): any;
}
type CFirewall=any;
export declare enum FirewallTypes {
    fwNone = 0,
    fwTunnel = 1,
    fwSOCKS4 = 2,
    fwSOCKS5 = 3,
    fwSOCKS4A = 10
}
export declare class Firewall {
    private obj;
    constructor(obj: CFirewall);
    constructor();
    unwrap(): CFirewall;
    getAutoDetect(): boolean;
    setAutoDetect(autoDetect: boolean): void;
    getFirewallType(): FirewallTypes;
    setFirewallType(firewallType: FirewallTypes): void;
    getHost(): string;
    setHost(host: string): void;
    getPassword(): string;
    setPassword(password: string): void;
    getPort(): number;
    setPort(port: number): void;
    getUser(): string;
    setUser(user: string): void;
    clone(): any;
}
export declare class FirewallList extends WrappedList<Firewall, CFirewall> {
    constructor(list: any, readOnly: boolean);
    protected_wrap(o: CFirewall): Firewall;
    protected_unwrap(o: Firewall): CFirewall;
    item(index: number): Firewall;
    addAll(c: Collection<Firewall>): boolean;
    addAll(index: number, c: Collection<Firewall>): boolean;
    addRange(c: Collection<Firewall>): void;
    size(): number;
    clone(): any;
}
type CProxy=any;
export declare enum ProxyAuthSchemes {
    authBasic = 0,
    authDigest = 1,
    authProprietary = 2,
    authNone = 3,
    authNtlm = 4,
    authNegotiate = 5
}
export declare enum ProxySSLTypes {
    psAutomatic = 0,
    psAlways = 1,
    psNever = 2,
    psTunnel = 3
}
export declare class Proxy {
    private obj;
    constructor(obj: CProxy);
    constructor();
    constructor(_server: string, port: number);
    constructor(_server: string, port: number, user: string, password: string);
    unwrap(): CProxy;
    getAuthScheme(): ProxyAuthSchemes;
    setAuthScheme(authScheme: ProxyAuthSchemes): void;
    getAutoDetect(): boolean;
    setAutoDetect(autoDetect: boolean): void;
    getPassword(): string;
    setPassword(password: string): void;
    getPort(): number;
    setPort(port: number): void;
    getServer(): string;
    setServer(_server: string): void;
    getSSL(): ProxySSLTypes;
    setSSL(SSL: ProxySSLTypes): void;
    getUser(): string;
    setUser(user: string): void;
    clone(): any;
}
export declare class ProxyList extends WrappedList<Proxy, CProxy> {
    constructor(list: any, readOnly: boolean);
    protected_wrap(o: CProxy): Proxy;
    protected_unwrap(o: Proxy): CProxy;
    item(index: number): Proxy;
    addAll(c: Collection<Proxy>): boolean;
    addAll(index: number, c: Collection<Proxy>): boolean;
    addRange(c: Collection<Proxy>): void;
    size(): number;
    clone(): any;
}
type CQueryParam=any;
export declare class QueryParam {
    private obj;
    constructor(obj: CQueryParam);
    constructor();
    constructor(name: string, value: string);
    unwrap(): CQueryParam;
    getName(): string;
    setName(name: string): void;
    getValue(): string;
    setValue(value: string): void;
    clone(): any;
}
export declare class QueryParamList extends WrappedList<QueryParam, CQueryParam> {
    constructor(list: any, readOnly: boolean);
    protected_wrap(o: CQueryParam): QueryParam;
    protected_unwrap(o: QueryParam): CQueryParam;
    item(index: number): QueryParam;
    addAll(c: Collection<QueryParam>): boolean;
    addAll(index: number, c: Collection<QueryParam>): boolean;
    addRange(c: Collection<QueryParam>): void;
    size(): number;
    clone(): any;
}
type CSMSMessage=any;
export declare class SMSMessage {
    private obj;
    constructor(obj: CSMSMessage);
    constructor();
    unwrap(): CSMSMessage;
    getBody(): string;
    setBody(body: string): void;
    getDirection(): number;
    getFrom(): string;
    setFrom(from: string): void;
    getMessageId(): string;
    getMessageStatus(): string;
    setMessageStatus(messageStatus: string): void;
    getTo(): string;
    setTo(to: string): void;
    clone(): any;
}
export declare class SMSMessageList extends WrappedList<SMSMessage, CSMSMessage> {
    constructor(list: any, readOnly: boolean);
    protected_wrap(o: CSMSMessage): SMSMessage;
    protected_unwrap(o: SMSMessage): CSMSMessage;
    item(index: number): SMSMessage;
    addAll(c: Collection<SMSMessage>): boolean;
    addAll(index: number, c: Collection<SMSMessage>): boolean;
    addRange(c: Collection<SMSMessage>): void;
    size(): number;
    clone(): any;
}
/************************************************** ENUMERATED TYPES **************************************************/
export declare enum SMSServiceProviders {
    spTwilio = 0,
    spSinch = 1,
    spSMSGlobal = 2,
    spSMSto = 3,
    spVonage = 4,
    spClickatell = 5
}
export declare enum SMSSSLProviders {
    sslpAutomatic = 0,
    sslpPlatform = 1,
    sslpInternal = 2
}
/**
 * The SMS component provides an easy way to manage short message service (SMS) messages from a variety of service providers.
 */
export declare class sms extends events.EventEmitter {
    private obj;
    constructor();
    about(): string;







    on(event: "DeliveryReport", listener: (e: {
        readonly messageId: string;
        readonly status: string;
    }) => void): this;
    on(event: "Error", listener: (e: {
        readonly errorCode: number;
        readonly description: string;
    }) => void): this;
    on(event: "IncomingMessage", listener: (e: {
        readonly messageId: string;
        readonly sentTo: string;
        readonly from: string;
        readonly body: string;
    }) => void): this;
    on(event: "Log", listener: (e: {
        readonly logLevel: number;
        readonly message: string;
        readonly logType: string;
    }) => void): this;
    on(event: "MessageList", listener: (e: {
        readonly messageId: string;
        readonly direction: number;
        readonly sentTo: string;
        readonly from: string;
        readonly messageStatus: string;
        readonly body: string;
    }) => void): this;
    on(event: "SSLServerAuthentication", listener: (e: {
        readonly certEncoded: string;
        readonly certEncodedB: Uint8Array;
        readonly certSubject: string;
        readonly certIssuer: string;
        readonly status: string;
        accept: boolean;
    }) => void): this;
    on(event: "SSLStatus", listener: (e: {
        readonly message: string;
    }) => void): this;
    once(event: "DeliveryReport", listener: (e: {
        readonly messageId: string;
        readonly status: string;
    }) => void): this;
    once(event: "Error", listener: (e: {
        readonly errorCode: number;
        readonly description: string;
    }) => void): this;
    once(event: "IncomingMessage", listener: (e: {
        readonly messageId: string;
        readonly sentTo: string;
        readonly from: string;
        readonly body: string;
    }) => void): this;
    once(event: "Log", listener: (e: {
        readonly logLevel: number;
        readonly message: string;
        readonly logType: string;
    }) => void): this;
    once(event: "MessageList", listener: (e: {
        readonly messageId: string;
        readonly direction: number;
        readonly sentTo: string;
        readonly from: string;
        readonly messageStatus: string;
        readonly body: string;
    }) => void): this;
    once(event: "SSLServerAuthentication", listener: (e: {
        readonly certEncoded: string;
        readonly certEncodedB: Uint8Array;
        readonly certSubject: string;
        readonly certIssuer: string;
        readonly status: string;
        accept: boolean;
    }) => void): this;
    once(event: "SSLStatus", listener: (e: {
        readonly message: string;
    }) => void): this;
    addListener(event: "DeliveryReport", listener: (e: {
        readonly messageId: string;
        readonly status: string;
    }) => void): this;
    addListener(event: "Error", listener: (e: {
        readonly errorCode: number;
        readonly description: string;
    }) => void): this;
    addListener(event: "IncomingMessage", listener: (e: {
        readonly messageId: string;
        readonly sentTo: string;
        readonly from: string;
        readonly body: string;
    }) => void): this;
    addListener(event: "Log", listener: (e: {
        readonly logLevel: number;
        readonly message: string;
        readonly logType: string;
    }) => void): this;
    addListener(event: "MessageList", listener: (e: {
        readonly messageId: string;
        readonly direction: number;
        readonly sentTo: string;
        readonly from: string;
        readonly messageStatus: string;
        readonly body: string;
    }) => void): this;
    addListener(event: "SSLServerAuthentication", listener: (e: {
        readonly certEncoded: string;
        readonly certEncodedB: Uint8Array;
        readonly certSubject: string;
        readonly certIssuer: string;
        readonly status: string;
        accept: boolean;
    }) => void): this;
    addListener(event: "SSLStatus", listener: (e: {
        readonly message: string;
    }) => void): this;
    prependListener(event: "DeliveryReport", listener: (e: {
        readonly messageId: string;
        readonly status: string;
    }) => void): this;
    prependListener(event: "Error", listener: (e: {
        readonly errorCode: number;
        readonly description: string;
    }) => void): this;
    prependListener(event: "IncomingMessage", listener: (e: {
        readonly messageId: string;
        readonly sentTo: string;
        readonly from: string;
        readonly body: string;
    }) => void): this;
    prependListener(event: "Log", listener: (e: {
        readonly logLevel: number;
        readonly message: string;
        readonly logType: string;
    }) => void): this;
    prependListener(event: "MessageList", listener: (e: {
        readonly messageId: string;
        readonly direction: number;
        readonly sentTo: string;
        readonly from: string;
        readonly messageStatus: string;
        readonly body: string;
    }) => void): this;
    prependListener(event: "SSLServerAuthentication", listener: (e: {
        readonly certEncoded: string;
        readonly certEncodedB: Uint8Array;
        readonly certSubject: string;
        readonly certIssuer: string;
        readonly status: string;
        accept: boolean;
    }) => void): this;
    prependListener(event: "SSLStatus", listener: (e: {
        readonly message: string;
    }) => void): this;
    prependOnceListener(event: "DeliveryReport", listener: (e: {
        readonly messageId: string;
        readonly status: string;
    }) => void): this;
    prependOnceListener(event: "Error", listener: (e: {
        readonly errorCode: number;
        readonly description: string;
    }) => void): this;
    prependOnceListener(event: "IncomingMessage", listener: (e: {
        readonly messageId: string;
        readonly sentTo: string;
        readonly from: string;
        readonly body: string;
    }) => void): this;
    prependOnceListener(event: "Log", listener: (e: {
        readonly logLevel: number;
        readonly message: string;
        readonly logType: string;
    }) => void): this;
    prependOnceListener(event: "MessageList", listener: (e: {
        readonly messageId: string;
        readonly direction: number;
        readonly sentTo: string;
        readonly from: string;
        readonly messageStatus: string;
        readonly body: string;
    }) => void): this;
    prependOnceListener(event: "SSLServerAuthentication", listener: (e: {
        readonly certEncoded: string;
        readonly certEncodedB: Uint8Array;
        readonly certSubject: string;
        readonly certIssuer: string;
        readonly status: string;
        accept: boolean;
    }) => void): this;
    prependOnceListener(event: "SSLStatus", listener: (e: {
        readonly message: string;
    }) => void): this;
    /**
     * Adds a query parameter to the QueryParams properties.
     */
    addQueryParam(name: string, value: string): Promise<void>;
    /**
     * Sets or retrieves a configuration setting.
     */
    config(configurationString: string): Promise<string>;
    /**
     * Deletes a received message from the account.
     */
    deleteReceivedMessage(messageId: string): Promise<void>;
    /**
     * Deletes a sent message from the account.
     */
    deleteSentMessage(messageId: string): Promise<void>;
    /**
     * This method processes events from the internal message queue.
     */
    doEvents(): Promise<void>;
    /**
     * Parses requests made to a web-hook.
     */
    handleWebhook(headerString: string, queryString: string, postData: Uint8Array): Promise<string>;
    /**
     * This method interrupts the current method.
     */
    interrupt(): Promise<void>;
    /**
     * Lists received messages from the account.
     */
    listReceivedMessages(filter: string): Promise<void>;
    /**
     * Lists messages sent from the account.
     */
    listSentMessages(filter: string): Promise<void>;
    /**
     * This method will reset the class.
     */
    reset(): Promise<void>;
    /**
     * Fetches a received message from the account.
     */
    retrieveReceivedMessage(messageId: string): Promise<void>;
    /**
     * Fetches a message sent from the account.
     */
    retrieveSentMessage(messageId: string): Promise<void>;
    /**
     * Schedules a message to be sent.
     */
    scheduleMessage(): Promise<string>;
    /**
     * Sends an SMS message.
     */
    send(): Promise<string>;
    /**
     * Updates a scheduled or sent message.
     */
    updateSentMessage(messageId: string): Promise<void>;
    /**
     * The account key associated with the service provider account.
     */
    getAccountKey(): string;
    /**
     * The account key associated with the service provider account.
     */
    setAccountKey(accountKey: string): void;
    /**
     * The account secret associated with the service provider account.
     */
    getAccountSecret(): string;
    /**
     * The account secret associated with the service provider account.
     */
    setAccountSecret(accountSecret: string): void;
    /**
     * A set of properties related to firewall access.
     */
    getFirewall(): Firewall;
    /**
     * A set of properties related to firewall access.
     */
    setFirewall(firewall: Firewall): void;
    /**
     * The current status of the class.
     */
    isIdle(): boolean;
    /**
     * The body of the SMS message that will be sent.
     */
    getMessageBody(): string;
    /**
     * The body of the SMS message that will be sent.
     */
    setMessageBody(messageBody: string): void;
    /**
     * The date and time when the SMS message will be sent.
     */
    getMessageDate(): string;
    /**
     * The date and time when the SMS message will be sent.
     */
    setMessageDate(messageDate: string): void;
    /**
     * The sender of the SMS message.
     */
    getMessageFrom(): string;
    /**
     * The sender of the SMS message.
     */
    setMessageFrom(messageFrom: string): void;
    /**
     * The recipient(s) of the SMS message.
     */
    getMessageRecipients(): string;
    /**
     * The recipient(s) of the SMS message.
     */
    setMessageRecipients(messageRecipients: string): void;
    getMessages(): SMSMessageList;
    /**
     * A set of properties related to proxy access.
     */
    getProxy(): Proxy;
    /**
     * A set of properties related to proxy access.
     */
    setProxy(proxy: Proxy): void;
    getQueryParams(): QueryParamList;
    /**
     * The service provider to use.
     */
    getServiceProvider(): SMSServiceProviders;
    /**
     * The service provider to use.
     */
    setServiceProvider(serviceProvider: SMSServiceProviders): void;
    /**
     * Instructs the class to unconditionally accept the server certificate that matches the supplied certificate.
     */
    getSSLAcceptServerCert(): Certificate;
    /**
     * Instructs the class to unconditionally accept the server certificate that matches the supplied certificate.
     */
    setSSLAcceptServerCert(SSLAcceptServerCert: Certificate): void;
    /**
     * The certificate to be used during Secure Sockets Layer (SSL) negotiation.
     */
    getSSLCert(): Certificate;
    /**
     * The certificate to be used during Secure Sockets Layer (SSL) negotiation.
     */
    setSSLCert(SSLCert: Certificate): void;
    /**
     * The Secure Sockets Layer/Transport Layer Security (SSL/TLS) implementation to use.
     */
    getSSLProvider(): SMSSSLProviders;
    /**
     * The Secure Sockets Layer/Transport Layer Security (SSL/TLS) implementation to use.
     */
    setSSLProvider(SSLProvider: SMSSSLProviders): void;
    /**
     * The server certificate for the last established connection.
     */
    getSSLServerCert(): Certificate;
}
