@types/node-forge

  • Version 0.9.9
  • Published
  • 43.4 kB
  • 1 dependency
  • MIT license

Install

npm i @types/node-forge
yarn add @types/node-forge
pnpm add @types/node-forge

Overview

TypeScript definitions for node-forge

Index

Namespaces

Namespaces

namespace node-forge

module 'node-forge' {}

    type Base64

    type Base64 = string;

      type Byte

      type Byte = number;

        type Bytes

        type Bytes = string;

          type Encoding

          type Encoding = 'raw' | 'utf8';

            type Hex

            type Hex = string;

              type OID

              type OID = string;

                type Utf8

                type Utf8 = string;

                  namespace node-forge.asn1

                  namespace node-forge.asn1 {}

                    function create

                    create: (
                    tagClass: Class,
                    type: Type,
                    constructed: boolean,
                    value: Bytes | Asn1[]
                    ) => Asn1;

                      function derToOid

                      derToOid: (der: util.ByteStringBuffer) => OID;

                        function fromDer

                        fromDer: (bytes: Bytes | util.ByteBuffer, strict?: boolean) => Asn1;

                          function oidToDer

                          oidToDer: (oid: OID) => util.ByteStringBuffer;

                            function toDer

                            toDer: (obj: Asn1) => util.ByteBuffer;

                              interface Asn1

                              interface Asn1 {}

                                property composed

                                composed: boolean;

                                  property constructed

                                  constructed: boolean;

                                    property tagClass

                                    tagClass: Class;

                                      property type

                                      type: Type;

                                        property value

                                        value: Bytes | Asn1[];

                                          enum Class

                                          enum Class {
                                          UNIVERSAL = 0x00,
                                          APPLICATION = 0x40,
                                          CONTEXT_SPECIFIC = 0x80,
                                          PRIVATE = 0xc0,
                                          }

                                            member APPLICATION

                                            APPLICATION = 0x40

                                              member CONTEXT_SPECIFIC

                                              CONTEXT_SPECIFIC = 0x80

                                                member PRIVATE

                                                PRIVATE = 0xc0

                                                  member UNIVERSAL

                                                  UNIVERSAL = 0x00

                                                    enum Type

                                                    enum Type {
                                                    NONE = 0,
                                                    BOOLEAN = 1,
                                                    INTEGER = 2,
                                                    BITSTRING = 3,
                                                    OCTETSTRING = 4,
                                                    NULL = 5,
                                                    OID = 6,
                                                    ODESC = 7,
                                                    EXTERNAL = 8,
                                                    REAL = 9,
                                                    ENUMERATED = 10,
                                                    EMBEDDED = 11,
                                                    UTF8 = 12,
                                                    ROID = 13,
                                                    SEQUENCE = 16,
                                                    SET = 17,
                                                    PRINTABLESTRING = 19,
                                                    IA5STRING = 22,
                                                    UTCTIME = 23,
                                                    GENERALIZEDTIME = 24,
                                                    BMPSTRING = 30,
                                                    }

                                                      member BITSTRING

                                                      BITSTRING = 3

                                                        member BMPSTRING

                                                        BMPSTRING = 30

                                                          member BOOLEAN

                                                          BOOLEAN = 1

                                                            member EMBEDDED

                                                            EMBEDDED = 11

                                                              member ENUMERATED

                                                              ENUMERATED = 10

                                                                member EXTERNAL

                                                                EXTERNAL = 8

                                                                  member GENERALIZEDTIME

                                                                  GENERALIZEDTIME = 24

                                                                    member IA5STRING

                                                                    IA5STRING = 22

                                                                      member INTEGER

                                                                      INTEGER = 2

                                                                        member NONE

                                                                        NONE = 0

                                                                          member NULL

                                                                          NULL = 5

                                                                            member OCTETSTRING

                                                                            OCTETSTRING = 4

                                                                              member ODESC

                                                                              ODESC = 7

                                                                                member OID

                                                                                OID = 6

                                                                                  member PRINTABLESTRING

                                                                                  PRINTABLESTRING = 19

                                                                                    member REAL

                                                                                    REAL = 9

                                                                                      member ROID

                                                                                      ROID = 13

                                                                                        member SEQUENCE

                                                                                        SEQUENCE = 16

                                                                                          member SET

                                                                                          SET = 17

                                                                                            member UTCTIME

                                                                                            UTCTIME = 23

                                                                                              member UTF8

                                                                                              UTF8 = 12

                                                                                                namespace node-forge.cipher

                                                                                                namespace node-forge.cipher {}

                                                                                                  function createCipher

                                                                                                  createCipher: (
                                                                                                  algorithm: Algorithm,
                                                                                                  payload: util.ByteBuffer | Bytes
                                                                                                  ) => BlockCipher;

                                                                                                    function createDecipher

                                                                                                    createDecipher: (
                                                                                                    algorithm: Algorithm,
                                                                                                    payload: util.ByteBuffer | Bytes
                                                                                                    ) => BlockCipher;

                                                                                                      interface BlockCipher

                                                                                                      interface BlockCipher {}

                                                                                                        property finish

                                                                                                        finish: () => boolean;

                                                                                                          property mode

                                                                                                          mode: Mode;

                                                                                                            property output

                                                                                                            output: util.ByteStringBuffer;

                                                                                                              property start

                                                                                                              start: (options?: StartOptions) => void;

                                                                                                                property update

                                                                                                                update: (payload: util.ByteBuffer) => void;

                                                                                                                  interface Mode

                                                                                                                  interface Mode {}

                                                                                                                    property tag

                                                                                                                    tag: util.ByteStringBuffer;

                                                                                                                      interface StartOptions

                                                                                                                      interface StartOptions {}

                                                                                                                        property additionalData

                                                                                                                        additionalData?: string;

                                                                                                                          property iv

                                                                                                                          iv?: util.ByteBuffer | Byte[] | Bytes;

                                                                                                                            property tag

                                                                                                                            tag?: util.ByteStringBuffer;

                                                                                                                              property tagLength

                                                                                                                              tagLength?: number;

                                                                                                                                type Algorithm

                                                                                                                                type Algorithm =
                                                                                                                                | 'AES-ECB'
                                                                                                                                | 'AES-CBC'
                                                                                                                                | 'AES-CFB'
                                                                                                                                | 'AES-OFB'
                                                                                                                                | 'AES-CTR'
                                                                                                                                | 'AES-GCM'
                                                                                                                                | '3DES-ECB'
                                                                                                                                | '3DES-CBC'
                                                                                                                                | 'DES-ECB'
                                                                                                                                | 'DES-CBC';

                                                                                                                                  namespace node-forge.hmac

                                                                                                                                  namespace node-forge.hmac {}

                                                                                                                                    function create

                                                                                                                                    create: () => HMAC;

                                                                                                                                      interface HMAC

                                                                                                                                      interface HMAC {}

                                                                                                                                        method digest

                                                                                                                                        digest: () => util.ByteBuffer;

                                                                                                                                          method getMact

                                                                                                                                          getMact: () => util.ByteBuffer;

                                                                                                                                            method start

                                                                                                                                            start: (md: Algorithm, key: string | util.ByteBuffer | null) => void;

                                                                                                                                              method update

                                                                                                                                              update: (bytes: string | util.ByteBuffer | Buffer) => void;

                                                                                                                                                type Algorithm

                                                                                                                                                type Algorithm = 'sha1' | 'md5' | 'sha256' | 'sha512';

                                                                                                                                                  namespace node-forge.jsbn

                                                                                                                                                  namespace node-forge.jsbn {}

                                                                                                                                                    class BigInteger

                                                                                                                                                    class BigInteger {}

                                                                                                                                                      property data

                                                                                                                                                      data: number[];

                                                                                                                                                        property s

                                                                                                                                                        s: number;

                                                                                                                                                          property t

                                                                                                                                                          t: number;

                                                                                                                                                            method bitLength

                                                                                                                                                            bitLength: () => number;

                                                                                                                                                              method toString

                                                                                                                                                              toString: () => string;

                                                                                                                                                                namespace node-forge.md

                                                                                                                                                                namespace node-forge.md {}

                                                                                                                                                                  interface MessageDigest

                                                                                                                                                                  interface MessageDigest {}

                                                                                                                                                                    method digest

                                                                                                                                                                    digest: () => util.ByteStringBuffer;

                                                                                                                                                                      method update

                                                                                                                                                                      update: (msg: string, encoding?: Encoding) => MessageDigest;

                                                                                                                                                                        namespace node-forge.md.hmac

                                                                                                                                                                        namespace node-forge.md.hmac {}

                                                                                                                                                                          namespace node-forge.md.md5

                                                                                                                                                                          namespace node-forge.md.md5 {}

                                                                                                                                                                            function create

                                                                                                                                                                            create: () => MessageDigest;

                                                                                                                                                                              namespace node-forge.md.sha1

                                                                                                                                                                              namespace node-forge.md.sha1 {}

                                                                                                                                                                                function create

                                                                                                                                                                                create: () => MessageDigest;

                                                                                                                                                                                  namespace node-forge.md.sha256

                                                                                                                                                                                  namespace node-forge.md.sha256 {}

                                                                                                                                                                                    function create

                                                                                                                                                                                    create: () => MessageDigest;

                                                                                                                                                                                      namespace node-forge.md.sha384

                                                                                                                                                                                      namespace node-forge.md.sha384 {}

                                                                                                                                                                                        function create

                                                                                                                                                                                        create: () => MessageDigest;

                                                                                                                                                                                          namespace node-forge.md.sha512

                                                                                                                                                                                          namespace node-forge.md.sha512 {}

                                                                                                                                                                                            function create

                                                                                                                                                                                            create: () => MessageDigest;

                                                                                                                                                                                              namespace node-forge.mgf

                                                                                                                                                                                              namespace node-forge.mgf {}

                                                                                                                                                                                                namespace node-forge.mgf.mgf1

                                                                                                                                                                                                namespace node-forge.mgf.mgf1 {}

                                                                                                                                                                                                  function create

                                                                                                                                                                                                  create: (any: any) => any;

                                                                                                                                                                                                    namespace node-forge.pem

                                                                                                                                                                                                    namespace node-forge.pem {}

                                                                                                                                                                                                      function decode

                                                                                                                                                                                                      decode: (str: string) => ObjectPEM[];

                                                                                                                                                                                                        function encode

                                                                                                                                                                                                        encode: (msg: ObjectPEM, options?: EncodeOptions) => string;

                                                                                                                                                                                                          interface EncodeOptions

                                                                                                                                                                                                          interface EncodeOptions {}

                                                                                                                                                                                                            property maxline

                                                                                                                                                                                                            maxline?: number;

                                                                                                                                                                                                              interface ObjectPEM

                                                                                                                                                                                                              interface ObjectPEM {}

                                                                                                                                                                                                                property body

                                                                                                                                                                                                                body: Bytes;

                                                                                                                                                                                                                  property contentDomain

                                                                                                                                                                                                                  contentDomain?: any;

                                                                                                                                                                                                                    property dekInfo

                                                                                                                                                                                                                    dekInfo?: any;

                                                                                                                                                                                                                      property headers

                                                                                                                                                                                                                      headers?: any[];

                                                                                                                                                                                                                        property procType

                                                                                                                                                                                                                        procType?: any;

                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                          type: string;

                                                                                                                                                                                                                            namespace node-forge.pkcs12

                                                                                                                                                                                                                            namespace node-forge.pkcs12 {}

                                                                                                                                                                                                                              function generateKey

                                                                                                                                                                                                                              generateKey: (
                                                                                                                                                                                                                              password: string | null | undefined,
                                                                                                                                                                                                                              salt: util.ByteBuffer,
                                                                                                                                                                                                                              id: Byte,
                                                                                                                                                                                                                              iter: number,
                                                                                                                                                                                                                              n: number,
                                                                                                                                                                                                                              md?: md.MessageDigest
                                                                                                                                                                                                                              ) => util.ByteBuffer;

                                                                                                                                                                                                                                function pkcs12FromAsn1

                                                                                                                                                                                                                                pkcs12FromAsn1: {
                                                                                                                                                                                                                                (obj: any, strict?: boolean, password?: string): Pkcs12Pfx;
                                                                                                                                                                                                                                (obj: any, password?: string): Pkcs12Pfx;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  function toPkcs12Asn1

                                                                                                                                                                                                                                  toPkcs12Asn1: (
                                                                                                                                                                                                                                  key: pki.PrivateKey,
                                                                                                                                                                                                                                  cert: pki.Certificate | pki.Certificate[],
                                                                                                                                                                                                                                  password: string | null,
                                                                                                                                                                                                                                  options?: {
                                                                                                                                                                                                                                  algorithm?: 'aes128' | 'aes192' | 'aes256' | '3des';
                                                                                                                                                                                                                                  count?: number;
                                                                                                                                                                                                                                  saltSize?: number;
                                                                                                                                                                                                                                  useMac?: boolean;
                                                                                                                                                                                                                                  localKeyId?: Hex;
                                                                                                                                                                                                                                  friendlyName?: string;
                                                                                                                                                                                                                                  generateLocalKeyId?: boolean;
                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                  ) => asn1.Asn1;

                                                                                                                                                                                                                                    interface Bag

                                                                                                                                                                                                                                    interface Bag {}

                                                                                                                                                                                                                                      property asn1

                                                                                                                                                                                                                                      asn1: asn1.Asn1;

                                                                                                                                                                                                                                        property attributes

                                                                                                                                                                                                                                        attributes: any;

                                                                                                                                                                                                                                          property cert

                                                                                                                                                                                                                                          cert?: pki.Certificate;

                                                                                                                                                                                                                                            property key

                                                                                                                                                                                                                                            key?: pki.PrivateKey;

                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                interface BagsFilter

                                                                                                                                                                                                                                                interface BagsFilter {}

                                                                                                                                                                                                                                                  property bagType

                                                                                                                                                                                                                                                  bagType?: string;

                                                                                                                                                                                                                                                    property friendlyName

                                                                                                                                                                                                                                                    friendlyName?: string;

                                                                                                                                                                                                                                                      property localKeyId

                                                                                                                                                                                                                                                      localKeyId?: string;

                                                                                                                                                                                                                                                        property localKeyIdHex

                                                                                                                                                                                                                                                        localKeyIdHex?: string;

                                                                                                                                                                                                                                                          interface Pkcs12Pfx

                                                                                                                                                                                                                                                          interface Pkcs12Pfx {}

                                                                                                                                                                                                                                                            property getBags

                                                                                                                                                                                                                                                            getBags: (
                                                                                                                                                                                                                                                            filter: BagsFilter
                                                                                                                                                                                                                                                            ) => {
                                                                                                                                                                                                                                                            [key: string]: Bag[] | undefined;
                                                                                                                                                                                                                                                            localKeyId?: Bag[];
                                                                                                                                                                                                                                                            friendlyName?: Bag[];
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              property getBagsByFriendlyName

                                                                                                                                                                                                                                                              getBagsByFriendlyName: (fiendlyName: string, bagType: string) => Bag[];

                                                                                                                                                                                                                                                                property getBagsByLocalKeyId

                                                                                                                                                                                                                                                                getBagsByLocalKeyId: (localKeyId: string, bagType: string) => Bag[];

                                                                                                                                                                                                                                                                  property safeContents

                                                                                                                                                                                                                                                                  safeContents: {
                                                                                                                                                                                                                                                                  encrypted: boolean;
                                                                                                                                                                                                                                                                  safeBags: Bag[];
                                                                                                                                                                                                                                                                  }[];

                                                                                                                                                                                                                                                                    property version

                                                                                                                                                                                                                                                                    version: string;

                                                                                                                                                                                                                                                                      namespace node-forge.pkcs5

                                                                                                                                                                                                                                                                      namespace node-forge.pkcs5 {}

                                                                                                                                                                                                                                                                        function pbkdf2

                                                                                                                                                                                                                                                                        pbkdf2: {
                                                                                                                                                                                                                                                                        (password: string, salt: string, iterations: number, keySize: number): string;
                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                        password: string,
                                                                                                                                                                                                                                                                        salt: string,
                                                                                                                                                                                                                                                                        iterations: number,
                                                                                                                                                                                                                                                                        keySize: number,
                                                                                                                                                                                                                                                                        messageDigest: md.MessageDigest
                                                                                                                                                                                                                                                                        ): string;
                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                        password: string,
                                                                                                                                                                                                                                                                        salt: string,
                                                                                                                                                                                                                                                                        iterations: number,
                                                                                                                                                                                                                                                                        keySize: number,
                                                                                                                                                                                                                                                                        callback: (err: Error, dk: string) => any
                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                        password: string,
                                                                                                                                                                                                                                                                        salt: string,
                                                                                                                                                                                                                                                                        iterations: number,
                                                                                                                                                                                                                                                                        keySize: number,
                                                                                                                                                                                                                                                                        messageDigest?: md.MessageDigest,
                                                                                                                                                                                                                                                                        callback?: (err: Error, dk: string) => any
                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          namespace node-forge.pkcs7

                                                                                                                                                                                                                                                                          namespace node-forge.pkcs7 {}

                                                                                                                                                                                                                                                                            function createEnvelopedData

                                                                                                                                                                                                                                                                            createEnvelopedData: () => PkcsEnvelopedData;

                                                                                                                                                                                                                                                                              function createSignedData

                                                                                                                                                                                                                                                                              createSignedData: () => PkcsSignedData;

                                                                                                                                                                                                                                                                                interface PkcsEnvelopedData

                                                                                                                                                                                                                                                                                interface PkcsEnvelopedData {}

                                                                                                                                                                                                                                                                                  property content

                                                                                                                                                                                                                                                                                  content?: string | util.ByteBuffer;

                                                                                                                                                                                                                                                                                    method addRecipient

                                                                                                                                                                                                                                                                                    addRecipient: (certificate: pki.Certificate) => void;

                                                                                                                                                                                                                                                                                      method encrypt

                                                                                                                                                                                                                                                                                      encrypt: () => void;

                                                                                                                                                                                                                                                                                        method toAsn1

                                                                                                                                                                                                                                                                                        toAsn1: () => asn1.Asn1;

                                                                                                                                                                                                                                                                                          interface PkcsSignedData

                                                                                                                                                                                                                                                                                          interface PkcsSignedData {}

                                                                                                                                                                                                                                                                                            property content

                                                                                                                                                                                                                                                                                            content?: string | util.ByteBuffer;

                                                                                                                                                                                                                                                                                              property contentInfo

                                                                                                                                                                                                                                                                                              contentInfo?: { value: any[] };

                                                                                                                                                                                                                                                                                                method addCertificate

                                                                                                                                                                                                                                                                                                addCertificate: (certificate: pki.Certificate | string) => void;

                                                                                                                                                                                                                                                                                                  method addSigner

                                                                                                                                                                                                                                                                                                  addSigner: (options: {
                                                                                                                                                                                                                                                                                                  key: string;
                                                                                                                                                                                                                                                                                                  certificate: pki.Certificate | string;
                                                                                                                                                                                                                                                                                                  digestAlgorithm: string;
                                                                                                                                                                                                                                                                                                  authenticatedAttributes: { type: string; value?: string }[];
                                                                                                                                                                                                                                                                                                  }) => void;

                                                                                                                                                                                                                                                                                                    method sign

                                                                                                                                                                                                                                                                                                    sign: (options?: { detached?: boolean }) => void;

                                                                                                                                                                                                                                                                                                      method toAsn1

                                                                                                                                                                                                                                                                                                      toAsn1: () => asn1.Asn1;

                                                                                                                                                                                                                                                                                                        namespace node-forge.pki

                                                                                                                                                                                                                                                                                                        namespace node-forge.pki {}

                                                                                                                                                                                                                                                                                                          variable oids

                                                                                                                                                                                                                                                                                                          var oids: oids;

                                                                                                                                                                                                                                                                                                            function certificateFromAsn1

                                                                                                                                                                                                                                                                                                            certificateFromAsn1: (obj: asn1.Asn1, computeHash?: boolean) => Certificate;

                                                                                                                                                                                                                                                                                                              function certificateFromPem

                                                                                                                                                                                                                                                                                                              certificateFromPem: (
                                                                                                                                                                                                                                                                                                              pem: PEM,
                                                                                                                                                                                                                                                                                                              computeHash?: boolean,
                                                                                                                                                                                                                                                                                                              strict?: boolean
                                                                                                                                                                                                                                                                                                              ) => Certificate;

                                                                                                                                                                                                                                                                                                                function certificateToAsn1

                                                                                                                                                                                                                                                                                                                certificateToAsn1: (cert: Certificate) => asn1.Asn1;

                                                                                                                                                                                                                                                                                                                  function certificateToPem

                                                                                                                                                                                                                                                                                                                  certificateToPem: (cert: Certificate, maxline?: number) => PEM;

                                                                                                                                                                                                                                                                                                                    function certificationRequestFromPem

                                                                                                                                                                                                                                                                                                                    certificationRequestFromPem: (
                                                                                                                                                                                                                                                                                                                    pem: PEM,
                                                                                                                                                                                                                                                                                                                    computeHash?: boolean,
                                                                                                                                                                                                                                                                                                                    strict?: boolean
                                                                                                                                                                                                                                                                                                                    ) => Certificate;

                                                                                                                                                                                                                                                                                                                      function certificationRequestToPem

                                                                                                                                                                                                                                                                                                                      certificationRequestToPem: (cert: Certificate, maxline?: number) => PEM;

                                                                                                                                                                                                                                                                                                                        function createCaStore

                                                                                                                                                                                                                                                                                                                        createCaStore: (certs?: ReadonlyArray<Certificate | pki.PEM>) => CAStore;

                                                                                                                                                                                                                                                                                                                          function createCertificate

                                                                                                                                                                                                                                                                                                                          createCertificate: () => Certificate;

                                                                                                                                                                                                                                                                                                                            function createCertificationRequest

                                                                                                                                                                                                                                                                                                                            createCertificationRequest: () => Certificate;

                                                                                                                                                                                                                                                                                                                              function decryptPrivateKeyInfo

                                                                                                                                                                                                                                                                                                                              decryptPrivateKeyInfo: (obj: asn1.Asn1, password: string) => asn1.Asn1;

                                                                                                                                                                                                                                                                                                                                function decryptRsaPrivateKey

                                                                                                                                                                                                                                                                                                                                decryptRsaPrivateKey: {
                                                                                                                                                                                                                                                                                                                                (pem: PEM, passphrase?: string): rsa.PrivateKey;
                                                                                                                                                                                                                                                                                                                                (pem: string, password: string): rsa.PrivateKey;
                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                  function encryptedPrivateKeyFromPem

                                                                                                                                                                                                                                                                                                                                  encryptedPrivateKeyFromPem: (pem: PEM) => asn1.Asn1;

                                                                                                                                                                                                                                                                                                                                    function encryptedPrivateKeyToPem

                                                                                                                                                                                                                                                                                                                                    encryptedPrivateKeyToPem: (obj: asn1.Asn1) => PEM;

                                                                                                                                                                                                                                                                                                                                      function encryptPrivateKeyInfo

                                                                                                                                                                                                                                                                                                                                      encryptPrivateKeyInfo: (
                                                                                                                                                                                                                                                                                                                                      obj: asn1.Asn1,
                                                                                                                                                                                                                                                                                                                                      password: string,
                                                                                                                                                                                                                                                                                                                                      options?: EncryptionOptions
                                                                                                                                                                                                                                                                                                                                      ) => asn1.Asn1;

                                                                                                                                                                                                                                                                                                                                        function encryptRsaPrivateKey

                                                                                                                                                                                                                                                                                                                                        encryptRsaPrivateKey: (
                                                                                                                                                                                                                                                                                                                                        privateKey: PrivateKey,
                                                                                                                                                                                                                                                                                                                                        password: string,
                                                                                                                                                                                                                                                                                                                                        options?: EncryptionOptions
                                                                                                                                                                                                                                                                                                                                        ) => PEM;

                                                                                                                                                                                                                                                                                                                                          function getPublicKeyFingerprint

                                                                                                                                                                                                                                                                                                                                          getPublicKeyFingerprint: {
                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                          publicKey: PublicKey,
                                                                                                                                                                                                                                                                                                                                          options?: ByteBufferFingerprintOptions
                                                                                                                                                                                                                                                                                                                                          ): util.ByteStringBuffer;
                                                                                                                                                                                                                                                                                                                                          (publicKey: any, options: HexFingerprintOptions): string;
                                                                                                                                                                                                                                                                                                                                          (publicKey: any, options: BinaryFingerprintOptions): string;
                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                            function pemToDer

                                                                                                                                                                                                                                                                                                                                            pemToDer: (pem: PEM) => util.ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                              function privateKeyFromAsn1

                                                                                                                                                                                                                                                                                                                                              privateKeyFromAsn1: (privateKey: asn1.Asn1) => PrivateKey;

                                                                                                                                                                                                                                                                                                                                                function privateKeyFromPem

                                                                                                                                                                                                                                                                                                                                                privateKeyFromPem: (pem: PEM) => rsa.PrivateKey;

                                                                                                                                                                                                                                                                                                                                                  function privateKeyInfoToPem

                                                                                                                                                                                                                                                                                                                                                  privateKeyInfoToPem: (key: asn1.Asn1, maxline?: number) => PEM;

                                                                                                                                                                                                                                                                                                                                                    function privateKeyToAsn1

                                                                                                                                                                                                                                                                                                                                                    privateKeyToAsn1: (privateKey: PrivateKey) => asn1.Asn1;

                                                                                                                                                                                                                                                                                                                                                      function privateKeyToPem

                                                                                                                                                                                                                                                                                                                                                      privateKeyToPem: (key: PrivateKey, maxline?: number) => PEM;

                                                                                                                                                                                                                                                                                                                                                        function publicKeyFromAsn1

                                                                                                                                                                                                                                                                                                                                                        publicKeyFromAsn1: (publicKey: asn1.Asn1) => PublicKey;

                                                                                                                                                                                                                                                                                                                                                          function publicKeyFromPem

                                                                                                                                                                                                                                                                                                                                                          publicKeyFromPem: (pem: PEM) => rsa.PublicKey;

                                                                                                                                                                                                                                                                                                                                                            function publicKeyToAsn1

                                                                                                                                                                                                                                                                                                                                                            publicKeyToAsn1: (publicKey: PublicKey) => asn1.Asn1;

                                                                                                                                                                                                                                                                                                                                                              function publicKeyToPem

                                                                                                                                                                                                                                                                                                                                                              publicKeyToPem: (key: PublicKey, maxline?: number) => PEM;

                                                                                                                                                                                                                                                                                                                                                                function publicKeyToRSAPublicKey

                                                                                                                                                                                                                                                                                                                                                                publicKeyToRSAPublicKey: (publicKey: PublicKey) => any;

                                                                                                                                                                                                                                                                                                                                                                  function publicKeyToRSAPublicKeyPem

                                                                                                                                                                                                                                                                                                                                                                  publicKeyToRSAPublicKeyPem: (key: PublicKey, maxline?: number) => PEM;

                                                                                                                                                                                                                                                                                                                                                                    function verifyCertificateChain

                                                                                                                                                                                                                                                                                                                                                                    verifyCertificateChain: (
                                                                                                                                                                                                                                                                                                                                                                    caStore: CAStore,
                                                                                                                                                                                                                                                                                                                                                                    chain: Certificate[],
                                                                                                                                                                                                                                                                                                                                                                    options?:
                                                                                                                                                                                                                                                                                                                                                                    | ((
                                                                                                                                                                                                                                                                                                                                                                    verified: boolean | string,
                                                                                                                                                                                                                                                                                                                                                                    depth: number,
                                                                                                                                                                                                                                                                                                                                                                    certs: Certificate[]
                                                                                                                                                                                                                                                                                                                                                                    ) => boolean)
                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                    verify?: (
                                                                                                                                                                                                                                                                                                                                                                    verified: boolean | string,
                                                                                                                                                                                                                                                                                                                                                                    depth: number,
                                                                                                                                                                                                                                                                                                                                                                    certs: Certificate[]
                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;
                                                                                                                                                                                                                                                                                                                                                                    validityCheckDate?: Date | null;
                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                      function wrapRsaPrivateKey

                                                                                                                                                                                                                                                                                                                                                                      wrapRsaPrivateKey: (privateKey: asn1.Asn1) => asn1.Asn1;

                                                                                                                                                                                                                                                                                                                                                                        interface Attribute

                                                                                                                                                                                                                                                                                                                                                                        interface Attribute {}

                                                                                                                                                                                                                                                                                                                                                                          property extensions

                                                                                                                                                                                                                                                                                                                                                                          extensions?: any[];
                                                                                                                                                                                                                                                                                                                                                                          • Extensions

                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                                                                                                                                                                                          • e.g. challengePassword

                                                                                                                                                                                                                                                                                                                                                                          property shortName

                                                                                                                                                                                                                                                                                                                                                                          shortName?: string;
                                                                                                                                                                                                                                                                                                                                                                          • Short name, if available (e.g. 'CN' for 'commonName')

                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                          type: string;
                                                                                                                                                                                                                                                                                                                                                                          • OID, e.g. '1.2.840.113549.1.9.7'

                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                          value: any;
                                                                                                                                                                                                                                                                                                                                                                          • Attribute value

                                                                                                                                                                                                                                                                                                                                                                          property valueTagClass

                                                                                                                                                                                                                                                                                                                                                                          valueTagClass: number;
                                                                                                                                                                                                                                                                                                                                                                          • Attribute value data type

                                                                                                                                                                                                                                                                                                                                                                          interface BinaryFingerprintOptions

                                                                                                                                                                                                                                                                                                                                                                          interface BinaryFingerprintOptions extends ByteBufferFingerprintOptions {}

                                                                                                                                                                                                                                                                                                                                                                            property encoding

                                                                                                                                                                                                                                                                                                                                                                            encoding: 'binary';
                                                                                                                                                                                                                                                                                                                                                                            • if not specified, the function will return ByteStringBuffer

                                                                                                                                                                                                                                                                                                                                                                            interface ByteBufferFingerprintOptions

                                                                                                                                                                                                                                                                                                                                                                            interface ByteBufferFingerprintOptions {}

                                                                                                                                                                                                                                                                                                                                                                              property delimiter

                                                                                                                                                                                                                                                                                                                                                                              delimiter?: string;
                                                                                                                                                                                                                                                                                                                                                                              • the delimiter to use between bytes for hex encoded output

                                                                                                                                                                                                                                                                                                                                                                              property md

                                                                                                                                                                                                                                                                                                                                                                              md?: md.MessageDigest;
                                                                                                                                                                                                                                                                                                                                                                              • if not specified defaults to md.md5

                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                              type?: 'SubjectPublicKeyInfo' | 'RSAPublicKey';
                                                                                                                                                                                                                                                                                                                                                                              • The type of fingerprint. If not specified, defaults to 'RSAPublicKey'

                                                                                                                                                                                                                                                                                                                                                                              interface CAStore

                                                                                                                                                                                                                                                                                                                                                                              interface CAStore {}

                                                                                                                                                                                                                                                                                                                                                                                method addCertificate

                                                                                                                                                                                                                                                                                                                                                                                addCertificate: (cert: Certificate | string) => void;

                                                                                                                                                                                                                                                                                                                                                                                  method getBySubject

                                                                                                                                                                                                                                                                                                                                                                                  getBySubject: (subject: string) => Certificate | null;

                                                                                                                                                                                                                                                                                                                                                                                    method getIssuer

                                                                                                                                                                                                                                                                                                                                                                                    getIssuer: (subject: Certificate) => Certificate | null;

                                                                                                                                                                                                                                                                                                                                                                                      method hasCertificate

                                                                                                                                                                                                                                                                                                                                                                                      hasCertificate: (cert: Certificate | string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                        method listAllCertificates

                                                                                                                                                                                                                                                                                                                                                                                        listAllCertificates: () => pki.Certificate[];

                                                                                                                                                                                                                                                                                                                                                                                          method removeCertificate

                                                                                                                                                                                                                                                                                                                                                                                          removeCertificate: (cert: Certificate | string) => Certificate | null;

                                                                                                                                                                                                                                                                                                                                                                                            interface Certificate

                                                                                                                                                                                                                                                                                                                                                                                            interface Certificate {}

                                                                                                                                                                                                                                                                                                                                                                                              property extensions

                                                                                                                                                                                                                                                                                                                                                                                              extensions: any[];

                                                                                                                                                                                                                                                                                                                                                                                                property issuer

                                                                                                                                                                                                                                                                                                                                                                                                issuer: {
                                                                                                                                                                                                                                                                                                                                                                                                getField(sn: string | CertificateFieldOptions): any;
                                                                                                                                                                                                                                                                                                                                                                                                addField(attr: CertificateField): void;
                                                                                                                                                                                                                                                                                                                                                                                                attributes: any[];
                                                                                                                                                                                                                                                                                                                                                                                                hash: any;
                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                  property md

                                                                                                                                                                                                                                                                                                                                                                                                  md: any;

                                                                                                                                                                                                                                                                                                                                                                                                    property privateKey

                                                                                                                                                                                                                                                                                                                                                                                                    privateKey: PrivateKey;

                                                                                                                                                                                                                                                                                                                                                                                                      property publicKey

                                                                                                                                                                                                                                                                                                                                                                                                      publicKey: PublicKey;

                                                                                                                                                                                                                                                                                                                                                                                                        property serialNumber

                                                                                                                                                                                                                                                                                                                                                                                                        serialNumber: string;

                                                                                                                                                                                                                                                                                                                                                                                                          property siginfo

                                                                                                                                                                                                                                                                                                                                                                                                          siginfo: any;

                                                                                                                                                                                                                                                                                                                                                                                                            property signature

                                                                                                                                                                                                                                                                                                                                                                                                            signature: any;

                                                                                                                                                                                                                                                                                                                                                                                                              property subject

                                                                                                                                                                                                                                                                                                                                                                                                              subject: {
                                                                                                                                                                                                                                                                                                                                                                                                              getField(sn: string | CertificateFieldOptions): any;
                                                                                                                                                                                                                                                                                                                                                                                                              addField(attr: CertificateField): void;
                                                                                                                                                                                                                                                                                                                                                                                                              attributes: any[];
                                                                                                                                                                                                                                                                                                                                                                                                              hash: any;
                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                property validity

                                                                                                                                                                                                                                                                                                                                                                                                                validity: {
                                                                                                                                                                                                                                                                                                                                                                                                                notBefore: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                notAfter: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                  property version

                                                                                                                                                                                                                                                                                                                                                                                                                  version: number;

                                                                                                                                                                                                                                                                                                                                                                                                                    method getAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                    getAttribute: (opts: string | GetAttributeOpts) => Attribute | null;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Gets an issuer or subject attribute from its name, type, or short name.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                      a short name string or an object with: shortName the short name for the attribute. name the name for the attribute. type the type for the attribute.

                                                                                                                                                                                                                                                                                                                                                                                                                      the attribute.

                                                                                                                                                                                                                                                                                                                                                                                                                    method getExtension

                                                                                                                                                                                                                                                                                                                                                                                                                    getExtension: (
                                                                                                                                                                                                                                                                                                                                                                                                                    options: string | { name: string } | { id: number }
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => {} | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Gets an extension by its name or id.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                      the name to use or an object with: name the name to use. id the id to use.

                                                                                                                                                                                                                                                                                                                                                                                                                      the extension or null if not found.

                                                                                                                                                                                                                                                                                                                                                                                                                    method isIssuer

                                                                                                                                                                                                                                                                                                                                                                                                                    isIssuer: (parent: Certificate) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns true if this certificate's issuer matches the passed certificate's subject. Note that no signature check is performed.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter parent

                                                                                                                                                                                                                                                                                                                                                                                                                      the certificate to check.

                                                                                                                                                                                                                                                                                                                                                                                                                      true if this certificate's issuer matches the passed certificate's subject.

                                                                                                                                                                                                                                                                                                                                                                                                                    method issued

                                                                                                                                                                                                                                                                                                                                                                                                                    issued: (child: Certificate) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns true if this certificate's subject matches the issuer of the given certificate). Note that not signature check is performed.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter child

                                                                                                                                                                                                                                                                                                                                                                                                                      the certificate to check.

                                                                                                                                                                                                                                                                                                                                                                                                                      true if this certificate's subject matches the passed certificate's issuer.

                                                                                                                                                                                                                                                                                                                                                                                                                    method setExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                    setExtensions: (exts: any[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Sets the extensions of this certificate.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter exts

                                                                                                                                                                                                                                                                                                                                                                                                                      the array of extensions to use.

                                                                                                                                                                                                                                                                                                                                                                                                                    method setIssuer

                                                                                                                                                                                                                                                                                                                                                                                                                    setIssuer: (attrs: CertificateField[], uniqueId?: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Sets the issuer of this certificate.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter attrs

                                                                                                                                                                                                                                                                                                                                                                                                                      the array of subject attributes to use.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter uniqueId

                                                                                                                                                                                                                                                                                                                                                                                                                      an optional a unique ID to use.

                                                                                                                                                                                                                                                                                                                                                                                                                    method setSubject

                                                                                                                                                                                                                                                                                                                                                                                                                    setSubject: (attrs: CertificateField[], uniqueId?: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Sets the subject of this certificate.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter attrs

                                                                                                                                                                                                                                                                                                                                                                                                                      the array of subject attributes to use.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter uniqueId

                                                                                                                                                                                                                                                                                                                                                                                                                      an optional a unique ID to use.

                                                                                                                                                                                                                                                                                                                                                                                                                    method sign

                                                                                                                                                                                                                                                                                                                                                                                                                    sign: (key: pki.PrivateKey, md?: md.MessageDigest) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Signs this certificate using the given private key.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter key

                                                                                                                                                                                                                                                                                                                                                                                                                      the private key to sign with.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter md

                                                                                                                                                                                                                                                                                                                                                                                                                      the message digest object to use (defaults to forge.md.sha1).

                                                                                                                                                                                                                                                                                                                                                                                                                    method verify

                                                                                                                                                                                                                                                                                                                                                                                                                    verify: (child: Certificate) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Attempts verify the signature on the passed certificate using this certificate's public key.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter child

                                                                                                                                                                                                                                                                                                                                                                                                                      the certificate to verify.

                                                                                                                                                                                                                                                                                                                                                                                                                      true if verified, false if not.

                                                                                                                                                                                                                                                                                                                                                                                                                    interface CertificateField

                                                                                                                                                                                                                                                                                                                                                                                                                    interface CertificateField extends CertificateFieldOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                      property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                      extensions?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                        value?: any[] | string;

                                                                                                                                                                                                                                                                                                                                                                                                                          property valueConstructed

                                                                                                                                                                                                                                                                                                                                                                                                                          valueConstructed?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                            property valueTagClass

                                                                                                                                                                                                                                                                                                                                                                                                                            valueTagClass?: asn1.Class;

                                                                                                                                                                                                                                                                                                                                                                                                                              interface CertificateFieldOptions

                                                                                                                                                                                                                                                                                                                                                                                                                              interface CertificateFieldOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property shortName

                                                                                                                                                                                                                                                                                                                                                                                                                                  shortName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAttributeOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAttributeOpts {}
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Attribute members to search on; any one hit will return the attribute

                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                      name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Long name

                                                                                                                                                                                                                                                                                                                                                                                                                                      property shortName

                                                                                                                                                                                                                                                                                                                                                                                                                                      shortName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Short name

                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • OID

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HexFingerprintOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HexFingerprintOptions extends ByteBufferFingerprintOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        property encoding

                                                                                                                                                                                                                                                                                                                                                                                                                                        encoding: 'hex';
                                                                                                                                                                                                                                                                                                                                                                                                                                        • if not specified, the function will return ByteStringBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface KeyPair

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface KeyPair {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property privateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                          privateKey: PrivateKey;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property publicKey

                                                                                                                                                                                                                                                                                                                                                                                                                                            publicKey: PublicKey;

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface oids

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface oids {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EncryptionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EncryptionOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  algorithm?: 'aes128' | 'aes192' | 'aes256' | '3des';
                                                                                                                                                                                                                                                                                                                                                                                                                                                  count?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  saltSize?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  prfAlgorithm?: 'sha1' | 'sha224' | 'sha256' | 'sha384' | 'sha512';
                                                                                                                                                                                                                                                                                                                                                                                                                                                  legacy?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PEM

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PEM = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PrivateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PrivateKey = rsa.PrivateKey | ed25519.Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PublicKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PublicKey = rsa.PublicKey | ed25519.Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type setRsaPublicKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type setRsaPublicKey = typeof rsa.setPublicKey;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace node-forge.pki.ed25519

                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace node-forge.pki.ed25519 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              function generateKeyPair

                                                                                                                                                                                                                                                                                                                                                                                                                                                              generateKeyPair: (options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              seed?: NativeBuffer | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              }) => { publicKey: NativeBuffer; privateKey: NativeBuffer };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                function publicKeyFromPrivateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                publicKeyFromPrivateKey: (options: { privateKey: BinaryBuffer }) => NativeBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sign: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: ToNativeBufferParameters & { privateKey: BinaryBuffer }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => NativeBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    verify: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: ToNativeBufferParameters & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    signature: BinaryBuffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    publicKey: BinaryBuffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BinaryBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BinaryBuffer = NativeBuffer | util.ByteBuffer | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Key = NativeBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NativeBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NativeBuffer = Buffer | Uint8Array;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ToNativeBufferParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ToNativeBufferParameters =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            message: NativeBuffer | util.ByteBuffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            message: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            encoding: 'binary' | 'utf8';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace node-forge.pki.ed25519.constants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace node-forge.pki.ed25519.constants {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable HASH_BYTE_LENGTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const HASH_BYTE_LENGTH: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable PRIVATE_KEY_BYTE_LENGTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const PRIVATE_KEY_BYTE_LENGTH: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable PUBLIC_KEY_BYTE_LENGTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const PUBLIC_KEY_BYTE_LENGTH: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable SEED_BYTE_LENGTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const SEED_BYTE_LENGTH: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable SIGN_BYTE_LENGTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const SIGN_BYTE_LENGTH: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace node-forge.pki.rsa

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace node-forge.pki.rsa {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function generateKeyPair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            generateKeyPair: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bits?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            e?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback?: (err: Error, keypair: KeyPair) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): KeyPair;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: GenerateKeyPairOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback?: (err: Error, keypair: KeyPair) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): KeyPair;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function setPublicKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setPublicKey: (n: jsbn.BigInteger, e: jsbn.BigInteger) => PublicKey;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GenerateKeyPairOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GenerateKeyPairOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  algorithm?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bits?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      e?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property prng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        prng?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property workers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          workers?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property workerScript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            workerScript?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property workLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              workLoad?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface KeyPair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface KeyPair {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property privateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  privateKey: PrivateKey;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property publicKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    publicKey: PublicKey;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PrivateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PrivateKey {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        d: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property dP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dP: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property dQ

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dQ: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              e: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property n

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                n: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property p

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  p: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property q

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    q: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property qInv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      qInv: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method decrypt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        decrypt: (data: Bytes, scheme?: EncryptionScheme, schemeOptions?: any) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sign: (md: md.MessageDigest, scheme?: SignatureScheme) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PublicKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PublicKey {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              e: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property n

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                n: jsbn.BigInteger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method encrypt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  encrypt: (data: Bytes, scheme?: EncryptionScheme, schemeOptions?: any) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    verify: (digest: Bytes, signature: Bytes, scheme?: SignatureScheme) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EncryptionScheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EncryptionScheme = 'RSAES-PKCS1-V1_5' | 'RSA-OAEP' | 'RAW' | 'NONE' | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SignatureScheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SignatureScheme = 'RSASSA-PKCS1-V1_5' | pss.PSS | 'NONE' | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace node-forge.pss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace node-forge.pss {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            create: (any: any) => PSS;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PSS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PSS = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace node-forge.random

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace node-forge.random {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function createInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createInstance: () => Random;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function getBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getBytes: (count: number, callback?: (bytes: Bytes) => any) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function getBytesSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getBytesSync: (count: number) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Random

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Random {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property seedFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          seedFile: (needed: number, cb: CB) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property seedFileSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            seedFileSync: (needed: number) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CB = (_: any, seed: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace node-forge.ssh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace node-forge.ssh {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function getPublicKeyFingerprint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getPublicKeyFingerprint: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  publicKey: pki.PublicKey,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: FingerprintOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => util.ByteStringBuffer | Hex | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Gets the SSH fingerprint for the given public key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function privateKeyToOpenSSH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  privateKeyToOpenSSH: (privateKey: pki.PrivateKey, passphrase?: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Encodes a private RSA key as an OpenSSH file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function privateKeyToPutty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  privateKeyToPutty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  privateKey: pki.PrivateKey,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  passphrase?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  comment?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Encodes (and optionally encrypts) a private RSA key as a Putty PPK file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function publicKeyToOpenSSH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  publicKeyToOpenSSH: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  publicKey: pki.PublicKey,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  comment?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => string | pki.PEM;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Encodes a public RSA key as an OpenSSH file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface FingerprintOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface FingerprintOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property delimiter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    delimiter?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • the delimiter to use between bytes for hex encoded output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property encoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    encoding?: 'hex' | 'binary';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • if not specified, the function will return ByteStringBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property md

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    md?: md.MessageDigest;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • if not specified defaults to md.md5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace node-forge.tls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace node-forge.tls {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable CipherSuites

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const CipherSuites: { [name: string]: CipherSuite };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable MaxFragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const MaxFragment: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable SupportedVersions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const SupportedVersions: ProtocolVersion[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable Version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const Version: ProtocolVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable Versions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const Versions: ProtocolVersion[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function createConnection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createConnection: (options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                server?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sessionId?: Bytes | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                caStore?: pki.CAStore | ReadonlyArray<pki.Certificate>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sessionCache?: SessionCache | { [key: string]: Session };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cipherSuites?: CipherSuite[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                connected(conn: Connection): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                virtualHost?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                verifyClient?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                verify?(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                conn: Connection,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                verified: Verified,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                depth: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                certs: pki.Certificate[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): Verified;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getCertificate?(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                conn: Connection,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hint: CertificateRequest | string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): pki.PEM | ReadonlyArray<pki.PEM>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getPrivateKey?(conn: Connection, certificate: pki.Certificate): pki.PEM;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getSignature?(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                conn: Connection,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bytes: Bytes,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (conn: Connection, bytes: Bytes) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tlsDataReady(conn: Connection): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dataReady(conn: Connection): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                heartbeatReceived?(conn: Connection, payload: util.ByteBuffer): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                closed(conn: Connection): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                error(conn: Connection, error: TLSError): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                deflate?(inBytes: Bytes): Bytes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                inflate?(inBytes: Bytes): Bytes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }) => Connection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function createSessionCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createSessionCache: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cache?: SessionCache | { [key: string]: Session },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  capacity?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => SessionCache;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function hmac_sha1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hmac_sha1: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: string | ReadonlyArray<Byte> | util.ByteBuffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    seqNum: [number, number],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    record: Record
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function prf_tls1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prf_tls1: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      secret: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      label: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      seed: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      length: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => util.ByteBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Alert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Alert {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          description: Alert.Description;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            level: Alert.Level;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CertificateRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CertificateRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property certificate_authorities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                certificate_authorities: util.ByteBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property certificate_types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  certificate_types: util.ByteBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CipherSuite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CipherSuite {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: [Byte, Byte];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Connection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Connection {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property caStore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            caStore: pki.CAStore;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cipherSuites

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cipherSuites: CipherSuite[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                data: util.ByteBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property deflate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  deflate: ((inBytes: Bytes) => Bytes) | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property entity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    entity: ConnectionEnd;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property expect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      expect: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fail: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fragmented

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fragmented: Record | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property getCertificate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getCertificate:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            conn: Connection,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hint: CertificateRequest | string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => pki.PEM | ReadonlyArray<pki.PEM>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property getPrivateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getPrivateKey:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((conn: Connection, certificate: pki.Certificate) => pki.PEM)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getSignature:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                conn: Connection,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bytes: Bytes,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (conn: Connection, bytes: Bytes) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property handshakes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  handshakes: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property handshaking

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    handshaking: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property heartbeatReceived

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      heartbeatReceived:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((conn: Connection, payload: util.ByteBuffer) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property inflate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inflate: ((inBytes: Bytes) => Bytes) | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          input: util.ByteBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isConnected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isConnected: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              open: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property peerCertificate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peerCertificate: pki.Certificate | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property record

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  record: Record | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property records

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    records: Record[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      session: Session | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sessionCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sessionCache: SessionCache | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property sessionId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sessionId: Bytes | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            state: { pending: ConnectionState | null; current: ConnectionState };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tlsData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tlsData: util.ByteBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property verifyClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                verifyClient: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  version: ProtocolVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property virtualHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    virtualHost: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      close: (clearFail?: boolean) => Connection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method closed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        closed: (conn: Connection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method connected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          connected: (conn: Connection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method dataReady

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dataReady: (conn: Connection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              error: (conn: Connection, error: TLSError) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handshake

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handshake: (sessionId?: Bytes | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method prepare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  prepare: (data: Bytes) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method prepareHeartbeatRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prepareHeartbeatRequest: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    payload: Bytes | util.ByteBuffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    payloadLength?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method process

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      process: (data: Bytes) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reset: (clearFail?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method tlsDataReady

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tlsDataReady: (conn: Connection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            verify: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            conn: Connection,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            verified: Verified,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            depth: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            certs: pki.Certificate[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Verified;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ProtocolVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ProtocolVersion {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property major

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                major: Byte;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property minor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  minor: Byte;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Record

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Record {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fragment: util.ByteBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ready?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: ContentType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              version: ProtocolVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Session {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cipherSuite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cipherSuite: CipherSuite | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property clientCertificate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clientCertificate: pki.Certificate | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property compressionMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      compressionMethod: CompressionMethod | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extensions: { [_: string]: object };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property md5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          md5: md.MessageDigest;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property serverCertificate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            serverCertificate: pki.Certificate | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sha1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sha1: md.MessageDigest;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                version: ProtocolVersion | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SessionCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SessionCache {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cache: { [key: string]: Session };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property capacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      capacity: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property order

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        order: [Hex];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getSession

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getSession: (sessionId: Bytes) => Session;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setSession

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setSession: (sessionId: Bytes, session: Session) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TLSError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TLSError extends Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property alert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                alert: Alert;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property origin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    origin: 'server' | 'client';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property send

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      send: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum BulkCipherAlgorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum BulkCipherAlgorithm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rc4 = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        des3 = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        aes = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member aes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          aes = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member des3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            des3 = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member rc4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rc4 = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum CipherType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum CipherType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stream = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                block = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                aead = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member aead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  aead = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    block = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member stream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stream = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum CompressionMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum CompressionMethod {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        none = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        deflate = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member deflate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deflate = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member none

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            none = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enum ConnectionEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enum ConnectionEnd {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              server = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              client = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                client = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  server = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum ContentType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum ContentType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    change_cipher_spec = 20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    alert = 21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    handshake = 22,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    application_data = 23,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    heartbeat = 24,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member alert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alert = 21

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member application_data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        application_data = 23

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member change_cipher_spec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          change_cipher_spec = 20

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member handshake

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handshake = 22

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member heartbeat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              heartbeat = 24

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum HandshakeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum HandshakeType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hello_request = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                client_hello = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                server_hello = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                certificate = 11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                server_key_exchange = 12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                certificate_request = 13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                server_hello_done = 14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                certificate_verify = 15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                client_key_exchange = 16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                finished = 20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member certificate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  certificate = 11

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member certificate_request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    certificate_request = 13

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member certificate_verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      certificate_verify = 15

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member client_hello

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        client_hello = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member client_key_exchange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          client_key_exchange = 16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member finished

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            finished = 20

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member hello_request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hello_request = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member server_hello

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                server_hello = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member server_hello_done

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  server_hello_done = 14

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member server_key_exchange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    server_key_exchange = 12

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum HeartbeatMessageType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum HeartbeatMessageType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      heartbeat_request = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      heartbeat_response = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member heartbeat_request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        heartbeat_request = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member heartbeat_response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          heartbeat_response = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum MACAlgorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum MACAlgorithm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hmac_md5 = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hmac_sha1 = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hmac_sha256 = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hmac_sha384 = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hmac_sha512 = 4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member hmac_md5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hmac_md5 = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member hmac_sha1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hmac_sha1 = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member hmac_sha256

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hmac_sha256 = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member hmac_sha384

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hmac_sha384 = 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member hmac_sha512

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hmac_sha512 = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum PRFAlgorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum PRFAlgorithm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tls_prf_sha256 = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member tls_prf_sha256

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tls_prf_sha256 = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ConnectionState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ConnectionState = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Verified

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Verified = true | { message?: string; alert?: Alert.Description };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace node-forge.tls.Alert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace node-forge.tls.Alert {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum Description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum Description {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  close_notify = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unexpected_message = 10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bad_record_mac = 20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  decryption_failed = 21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  record_overflow = 22,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  decompression_failure = 30,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  handshake_failure = 40,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bad_certificate = 42,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unsupported_certificate = 43,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  certificate_revoked = 44,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  certificate_expired = 45,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  certificate_unknown = 46,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  illegal_parameter = 47,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unknown_ca = 48,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  access_denied = 49,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  decode_error = 50,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  decrypt_error = 51,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  export_restriction = 60,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protocol_version = 70,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  insufficient_security = 71,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  internal_error = 80,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  user_canceled = 90,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  no_renegotiation = 100,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member access_denied

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    access_denied = 49

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member bad_certificate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bad_certificate = 42

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member bad_record_mac

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bad_record_mac = 20

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member certificate_expired

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          certificate_expired = 45

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member certificate_revoked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            certificate_revoked = 44

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member certificate_unknown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              certificate_unknown = 46

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member close_notify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                close_notify = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member decode_error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  decode_error = 50

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member decompression_failure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    decompression_failure = 30

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member decrypt_error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      decrypt_error = 51

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member decryption_failed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        decryption_failed = 21

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member export_restriction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          export_restriction = 60

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member handshake_failure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handshake_failure = 40

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member illegal_parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              illegal_parameter = 47

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member insufficient_security

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                insufficient_security = 71

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member internal_error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  internal_error = 80

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member no_renegotiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    no_renegotiation = 100

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member protocol_version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protocol_version = 70

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member record_overflow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        record_overflow = 22

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member unexpected_message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unexpected_message = 10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member unknown_ca

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unknown_ca = 48

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member unsupported_certificate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unsupported_certificate = 43

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member user_canceled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                user_canceled = 90

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum Level {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  warning = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fatal = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member fatal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fatal = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member warning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      warning = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace node-forge.util

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace node-forge.util {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function bytesToHex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bytesToHex: (bytes: Bytes) => Hex;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function createBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (): ByteBuffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            input: string | ByteStringBuffer | ArrayBuffer | ArrayBufferView,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            encoding?: Encoding
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): ByteStringBuffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function decode64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              decode64: (encoded: Base64) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function decodeUtf8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                decodeUtf8: (encoded: Utf8) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function encode64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  encode64: (bytes: Bytes, maxline?: number) => Base64;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function encodeUtf8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    encodeUtf8: (str: string) => Utf8;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function fillString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fillString: (char: string, count: number) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function hexToBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hexToBytes: (hex: Hex) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function int32ToBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          int32ToBytes: (int: number) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isArray: (x: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isArrayBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isArrayBuffer: (x: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function isArrayBufferView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isArrayBufferView: (x: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function xorBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  xorBytes: (bytes1: string, bytes2: string, count: number) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ByteStringBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ByteStringBuffer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(bytes?: string | ByteStringBuffer | ArrayBuffer | ArrayBufferView);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          read: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            at: (index: number) => Byte;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method bytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bytes: (count?: number) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                clear: () => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method compact

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  compact: () => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method copy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    copy: () => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method fillWithByte

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fillWithByte: (byte: Byte, n: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getByte

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getByte: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getBytes: (count?: number) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getInt: (numOfBits: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getInt16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getInt16: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getInt16Le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getInt16Le: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getInt24

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getInt24: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getInt24Le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getInt24Le: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getInt32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getInt32: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getInt32Le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getInt32Le: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getSignedInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getSignedInt: (numOfBits: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isEmpty: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method last

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              last: () => Byte;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                length: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method putBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  putBuffer: (buffer: ByteStringBuffer) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method putByte

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    putByte: (byte: Byte) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method putBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      putBytes: (bytes: Bytes) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method putInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        putInt: (int: number, numOfBits: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method putInt16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          putInt16: (int: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method putInt16Le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            putInt16Le: (int: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method putInt24

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              putInt24: (int: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method putInt24Le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                putInt24Le: (int: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method putInt32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  putInt32: (int: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method putInt32Le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    putInt32Le: (int: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method putSignedInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      putSignedInt: (int: number, numOfBits: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method putString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        putString: (str: string) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setAt: (index: number, byte: number) => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method toHex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toHex: () => Hex;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method truncate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                truncate: () => ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ArrayBufferView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ArrayBufferView {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    buffer: ArrayBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property byteLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      byteLength: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ByteBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ByteBuffer = ByteStringBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace node-forge.util.binary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace node-forge.util.binary {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace node-forge.util.binary.base64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace node-forge.util.binary.base64 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              decode: (input: Base64, output?: Uint8Array, offset?: number) => Uint8Array;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                encode: (input: Uint8Array, maxline?: number) => Base64;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace node-forge.util.binary.hex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace node-forge.util.binary.hex {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    decode: (hex: Hex, output?: Uint8Array, offset?: number) => Uint8Array;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      encode: (bytes: Bytes | ArrayBuffer | ArrayBufferView | ByteStringBuffer) => Hex;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace node-forge.util.binary.raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace node-forge.util.binary.raw {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          decode: (str: Bytes, output?: Uint8Array, offset?: number) => Uint8Array;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            encode: (x: Uint8Array) => Bytes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace node-forge.util.text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace node-forge.util.text {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace node-forge.util.text.utf16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace node-forge.util.text.utf16 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  decode: (bytes: Uint8Array) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    encode: (str: string, output?: Uint8Array, offset?: number) => Uint8Array;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace node-forge.util.text.utf8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace node-forge.util.text.utf8 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        decode: (bytes: Uint8Array) => Utf8;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          encode: (str: string, output?: Uint8Array, offset?: number) => Uint8Array;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/node-forge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/node-forge)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@types/node-forge"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>