jspurefix 2.2.0 → 3.0.0

package/src/transport/tcp/tcp-acceptor.ts

@@ -11,21 +11,21 @@ import { DITokens } from '../../runtime/di-tokens'
 @injectable()
 export class TcpAcceptor extends FixAcceptor {
   private server: Server
-  private logger: IJsFixLogger
+  private readonly logger: IJsFixLogger
   private nextId: number = 0
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
-    super(config.description.application)
-    this.logger = config.logFactory.logger(`${config.description.application.name}:TcpAcceptor`)
-    const tlsOptions: TlsOptions = this.tlsOptions()
+    super(config.description.application ?? null)
+    this.logger = config.logFactory.logger(`${config.description.application?.name}:TcpAcceptor`)
+    const tlsOptions: TlsOptions | null = this.tlsOptions()
     if (tlsOptions) {
       this.tlsServer()
     } else {
       this.unsecureServer()
     }
-    this.server.on('error', ((err: Error) => {
+    this.server.on('error', (err: Error) => {
       throw err
-    }))
+    })
   }
 
   getId (): number {
@@ -36,12 +36,13 @@ export class TcpAcceptor extends FixAcceptor {
   tlsServer (): void {
     try {
       const config: IJsFixConfig = this.config
-      const tcp = this.config.description.application.tcp
-      const tlsOptions: TlsOptions = TlsOptionsFactory.getTlsOptions(tcp.tls)
-      this.logger.info(`create tls server`)
+      const tcp = this.config.description.application?.tcp
+      const tlsOptions: TlsOptions | null = tcp?.tls ? TlsOptionsFactory.getTlsOptions(tcp.tls) : null
+      this.logger.info('create tls server')
+      if (!tlsOptions) return
       this.server = tlsCreateServer(tlsOptions, (tlsSocket: TLSSocket) => {
-        if (tcp.tls.enableTrace) {
-          this.logger.info(`enabling tls session trace`)
+        if (tcp?.tls?.enableTrace) {
+          this.logger.info('enabling tls session trace')
           tlsSocket.enableTrace()
         }
         if (tlsSocket.authorized) {
@@ -50,7 +51,7 @@ export class TcpAcceptor extends FixAcceptor {
           this.logger.info(`tls creates session ${id} ${tlsSocket.authorized}`)
           this.onSocket(id, tlsSocket, config)
         } else {
-          this.logger.info(`no transport created on tls with no authorized connection`)
+          this.logger.info('no transport created on tls with no authorized connection')
         }
       })
     } catch (e) {
@@ -59,10 +60,10 @@ export class TcpAcceptor extends FixAcceptor {
     }
   }
 
-  unsecureServer () {
+  unsecureServer (): void {
     try {
       const config = this.config
-      this.logger.info(`create unsecured server`)
+      this.logger.info('create unsecured server')
       this.server = netCreateServer((socket: Socket) => {
         const id: number = this.getId()
         this.logger.info(`net creates session ${id}`)
@@ -75,12 +76,12 @@ export class TcpAcceptor extends FixAcceptor {
     }
   }
 
-  tlsOptions (): TlsOptions {
-    const tcp = this.config.description.application.tcp
-    return TlsOptionsFactory.getTlsOptions(tcp.tls)
+  tlsOptions (): TlsOptions | null {
+    const tcp = this.config.description.application?.tcp
+    return tcp?.tls ? TlsOptionsFactory.getTlsOptions(tcp?.tls) : null
   }
 
-  private onSocket (id: number, socket: Socket, config: IJsFixConfig) {
+  private onSocket (id: number, socket: Socket, config: IJsFixConfig): void {
     const transport: MsgTransport = new MsgTransport(id, config, new TcpDuplex(socket))
     this.saveTransport(id, transport)
     transport.receiver.on('end', () => {
@@ -93,7 +94,7 @@ export class TcpAcceptor extends FixAcceptor {
   }
 
   public listen (): void {
-    const port = this.config.description.application.tcp.port
+    const port = this.config.description.application?.tcp?.port
     this.logger.info(`start to listen ${port}`)
     this.server.on('connection', () => {
       this.logger.info('insecure connection established')
@@ -105,19 +106,19 @@ export class TcpAcceptor extends FixAcceptor {
   }
 
   public close (callback?: (err?: Error) => void): void {
-    const port = this.config.description.application.tcp.port
+    const port = this.config.description.application?.tcp?.port ?? -1
     this.logger.info(`close listener on port ${port}`)
     this.server.close(callback)
   }
 
-  private saveTransport (tid: number, transport: MsgTransport) {
+  private saveTransport (tid: number, transport: MsgTransport): void {
     this.transports[tid] = transport
     const keys: string[] = Object.keys(this.transports)
     this.logger.info(`new transport id = ${tid} created total transports = ${keys.length}`)
     this.emit('transport', transport)
   }
 
-  private harvestTransport (tid: number) {
+  private harvestTransport (tid: number): void {
     delete this.transports[tid]
     const keys: string[] = Object.keys(this.transports)
     this.logger.info(`transport ${tid} ends total transports = ${keys.length}`)

package/src/transport/tcp/tcp-initiator-connector.ts

@@ -12,8 +12,10 @@ export class TcpInitiatorConnector extends FixEntity {
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config)
   }
-  start (reconnectTimeout: number = 0): Promise<any> {
-    return new Promise<any>(async (accept, reject) => {
+
+  async start (reconnectTimeout: number = 0): Promise<any> {
+    // eslint-disable-next-line no-async-promise-executor
+    return await new Promise<any>(async (resolve, reject) => {
       const logger = this.config.logFactory.logger('initiator')
       const sessionContainer = this.config.sessionContainer
       if (!sessionContainer.isRegistered(DITokens.FixSession)) {
@@ -27,7 +29,7 @@ export class TcpInitiatorConnector extends FixEntity {
           await this.connect(initiatorSession)
           logger.info('session has ended')
           connecting = false
-          accept(true)
+          resolve(true)
         } catch (e) {
           if (!reconnectTimeout) {
             connecting = false
@@ -41,14 +43,18 @@ export class TcpInitiatorConnector extends FixEntity {
     })
   }
 
-  delay (p: number): Promise<any> {
-    return new Promise<any>((accept) => {
-      if (!p) {
-        accept(true)
+  async delay (p: number): Promise<any> {
+    return await new Promise<any>((resolve, reject) => {
+      try {
+        if (!p) {
+          resolve(true)
+        }
+        setTimeout(() => {
+          resolve(true)
+        }, p)
+      } catch (e) {
+        reject(e)
       }
-      setTimeout(() => {
-        accept(true)
-      }, p)
     })
   }
 

package/src/transport/tcp/tcp-initiator.ts

@@ -23,21 +23,22 @@ export enum InitiatorState {
 
 @injectable()
 export class TcpInitiator extends FixInitiator {
-  public tcp: ITcpTransportDescription
+  public tcp: ITcpTransportDescription | null
   public state: InitiatorState = InitiatorState.Idle
   private readonly logger: IJsFixLogger
   private duplex: FixDuplex
-  private th: Timeout = null
+  private th: Timeout | null = null
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly jsFixConfig: IJsFixConfig) {
-    super(jsFixConfig.description.application)
-    this.logger = jsFixConfig.logFactory.logger(`${this.application.name}:TcpInitiator`)
+    super(jsFixConfig.description.application ?? null)
+    const name = this.application?.name ?? 'initiator'
+    this.logger = jsFixConfig.logFactory.logger(`${name}:TcpInitiator`)
     if (!this.application) {
-      throw new Error(`no application in session description.`)
+      throw new Error('no application in session description.')
     }
-    this.tcp = this.application.tcp
+    this.tcp = this.application.tcp ?? null
     if (!this.tcp) {
-      throw new Error(`no tcp in session description need tcp { host: hostname, port: port }`)
+      throw new Error('no tcp in session description need tcp { host: hostname, port: port }')
     }
   }
 
@@ -59,15 +60,15 @@ export class TcpInitiator extends FixInitiator {
     }
   }
 
-  public connect (timeoutSeconds: number): Promise<MsgTransport> {
-    return new Promise<MsgTransport>(async (resolve, reject) => {
+  public async connect (timeoutSeconds: number): Promise<MsgTransport> {
+    return await new Promise<MsgTransport>(async (resolve, reject) => {
       switch (this.state) {
         case InitiatorState.Idle: {
           this.state = InitiatorState.Connecting
           this.logger.info(`connecting with timeout ${timeoutSeconds}`)
           this.tryConnect()
             .then((t: MsgTransport) => resolve(t))
-            .catch((e: Error) => {
+            .catch((_: Error) => {
               this.repeatConnect(timeoutSeconds)
                 .then((t: MsgTransport) => resolve(t))
                 .catch((e: Error) => reject(e))
@@ -75,29 +76,36 @@ export class TcpInitiator extends FixInitiator {
           break
         }
 
-        default:
-          const e: Error = new Error(`connect not valid from non idle state`)
+        default: {
+          const e: Error = new Error('connect not valid from non idle state')
           this.logger.warning(`rejecting from state ${this.state}`)
           reject(e)
+        }
       }
     })
   }
 
-  private unsecureDuplex (): Promise<TcpDuplex> {
+  private async unsecureDuplex (): Promise<TcpDuplex> {
     const tcp = this.tcp
-    return new Promise<TcpDuplex>((resolve, reject) => {
+    return await new Promise<TcpDuplex>((resolve, reject) => {
       try {
-        this.logger.info(`unsecureDuplex try to connect to endPoint`)
-        const socket = createConnection(tcp, () => {
-          try {
-            this.logger.info(`net.createConnection cb, resolving`)
-            const tcpDuplex = new TcpDuplex(socket)
-            resolve(tcpDuplex)
-          } catch (e) {
-            reject(e)
-          }
-        })
-        socket.on('error', (err) => {
+        this.logger.info('unsecureDuplex try to connect to endPoint')
+        const socket = tcp
+          ? createConnection(tcp, () => {
+            try {
+              this.logger.info('net.createConnection cb, resolving')
+              if (socket) {
+                const tcpDuplex = new TcpDuplex(socket)
+                resolve(tcpDuplex)
+              } else {
+                reject(new Error('no socket in tcp initiator'))
+              }
+            } catch (e) {
+              reject(e)
+            }
+          })
+          : null
+        socket?.on('error', (err) => {
           reject(err)
         })
       } catch (e) {
@@ -106,14 +114,15 @@ export class TcpInitiator extends FixInitiator {
     })
   }
 
-  private tlsDuplex (): Promise < TcpDuplex > {
-    return new Promise<TcpDuplex>((resolve, reject) => {
-      let tlsSocket: TLSSocket = null
+  private async tlsDuplex (): Promise<TcpDuplex > {
+    return await new Promise<TcpDuplex>((resolve, reject) => {
+      let tlsSocket: TLSSocket | null = null
       const tcp = this.tcp
-      const connectionOptions: ConnectionOptions = TlsOptionsFactory.getTlsConnectionOptions(tcp)
+      const connectionOptions: ConnectionOptions | null = tcp ? TlsOptionsFactory.getTlsConnectionOptions(tcp) : null
       if (connectionOptions) {
         try {
           tlsSocket = tlsConnect(connectionOptions, () => {
+            if (!tlsSocket) return null
             this.logger.info(`client connected ${tlsSocket.authorized ? 'authorized' : 'unauthorized'}`)
             if (!tlsSocket.authorized) {
               const error = tlsSocket.authorizationError
@@ -123,11 +132,11 @@ export class TcpInitiator extends FixInitiator {
             } else {
               tlsSocket.setEncoding('utf8')
               const tlsDuplex = new TcpDuplex(tlsSocket)
-              if (tcp.tls.enableTrace) {
-                this.logger.info(`enabling tls session trace`)
+              if (tcp?.tls?.enableTrace) {
+                this.logger.info('enabling tls session trace')
                 tlsSocket.enableTrace()
               }
-              this.logger.info(`tlsDuplex resolving`)
+              this.logger.info('tlsDuplex resolving')
               resolve(tlsDuplex)
             }
           })
@@ -141,12 +150,12 @@ export class TcpInitiator extends FixInitiator {
     })
   }
 
-  private tryConnect (): Promise < MsgTransport > {
-    return new Promise<MsgTransport>((resolve, reject) => {
+  private async tryConnect (): Promise < MsgTransport > {
+    return await new Promise<MsgTransport>((resolve, reject) => {
       const tcp = this.tcp
-      const connectionOptions: ConnectionOptions = TlsOptionsFactory.getTlsConnectionOptions(tcp)
+      const connectionOptions: ConnectionOptions | null = tcp ? TlsOptionsFactory.getTlsConnectionOptions(tcp) : null
       const connector = connectionOptions ? this.tlsDuplex() : this.unsecureDuplex()
-      this.logger.info(`tryConnect ${tcp.host}:${tcp.port}`)
+      this.logger.info(`tryConnect ${tcp?.host}:${tcp?.port}`)
       connector.then(duplex => {
         this.duplex = duplex
         resolve(new MsgTransport(0, this.jsFixConfig, duplex))
@@ -156,20 +165,22 @@ export class TcpInitiator extends FixInitiator {
     })
   }
 
-  public clearTimer () {
-    if (this .th) {
+  public clearTimer (): void {
+    if (this.th) {
       clearInterval(this.th)
       this.th = null
     }
   }
 
-  private repeatConnect (timeoutSeconds: number): Promise < MsgTransport > {
-    return new Promise<MsgTransport>(async (resolve, reject) => {
+  private async repeatConnect (timeoutSeconds: number): Promise < MsgTransport > {
+    return await new Promise<MsgTransport>(async (resolve, reject) => {
       const application = this.application
       const promisify = util.promisify
       const timeoutPromise = promisify(setTimeout)
+      const reconnectSeconds = application?.reconnectSeconds ?? 5
       let retries = 0
       let lastError: Error
+      const name = application?.name ?? 'initiator'
       this.th = setInterval(() => {
         ++retries
         this.tryConnect()
@@ -177,15 +188,15 @@ export class TcpInitiator extends FixInitiator {
             this.state = InitiatorState.Connected
             this.clearTimer()
             resolve(t)
-        }).catch((e: Error) => {
-          lastError = e
-          this.logger.info(`${application.name}: retries ${retries} ${e.message}`)
-        })
-      }, application.reconnectSeconds * 1000)
+          }).catch((e: Error) => {
+            lastError = e
+            this.logger.info(`${name}: retries ${retries} ${e.message}`)
+          })
+      }, reconnectSeconds * 1000)
       timeoutPromise(timeoutSeconds * 1000).then(() => {
         this.clearTimer()
         this.state = InitiatorState.Stopped
-        const e = lastError ?? new Error(`${application.name}: timeout of ${timeoutSeconds} whilst connecting`)
+        const e = lastError ?? new Error(`${name}: timeout of ${timeoutSeconds} whilst connecting`)
         reject(e)
       }).catch(e => {
         reject(e)

package/src/transport/tcp/tcp-transport-description.ts

@@ -2,6 +2,6 @@ import { ITlsOptions } from './tls-options'
 
 export interface ITcpTransportDescription {
   readonly port: number
-  readonly host: string,
+  readonly host: string
   readonly tls?: ITlsOptions
 }

package/src/transport/tcp/tls-options-factory.ts

@@ -5,7 +5,7 @@ const path = require('path')
 const fs = require('fs')
 
 export class TlsOptionsFactory {
-  static read (filePath: string) {
+  static read (filePath: string): string {
     const root: string = path.join(__dirname, '../../../')
     const fullPath = path.join(root, filePath)
     return fs.readFileSync(fullPath,
@@ -14,8 +14,8 @@ export class TlsOptionsFactory {
       })
   }
 
-  static getTlsOptions (tls: ITlsOptions): TlsOptions {
-    let tlsOptions: TlsOptions = null
+  static getTlsOptions (tls: ITlsOptions): TlsOptions | null {
+    let tlsOptions: TlsOptions | null = null
     if (tls) {
       tlsOptions = {
         requestCert: tls.requestCert,
@@ -24,18 +24,25 @@ export class TlsOptionsFactory {
 
       if (tls.key) {
         tlsOptions.key = TlsOptionsFactory.read(tls.key)
-        tlsOptions.cert = TlsOptionsFactory.read(tls.cert)
+        tlsOptions.cert = tls?.cert ? TlsOptionsFactory.read(tls?.cert) : undefined
       }
-      
+
       if (tls.ca && tls.ca.length > 0) {
         tlsOptions.ca = tls.ca.map(i => TlsOptionsFactory.read(i))
       }
+
+      if (tls.nodeTlsServerOptions) {
+        tlsOptions = {
+          ...tlsOptions,
+          ...tls.nodeTlsServerOptions
+        }
+      }
     }
     return tlsOptions
   }
 
-  static getTlsConnectionOptions (tcp: ITcpTransportDescription): ConnectionOptions {
-    let connectionOptions: ConnectionOptions = null
+  static getTlsConnectionOptions (tcp: ITcpTransportDescription): ConnectionOptions | null {
+    let connectionOptions: ConnectionOptions | null = null
     const tls = tcp.tls
     if (tls) {
       connectionOptions = {
@@ -43,8 +50,8 @@ export class TlsOptionsFactory {
         host: tcp.host
       } as ConnectionOptions
       if (tls.key) {
-        connectionOptions.key = TlsOptionsFactory.read(tcp.tls.key)
-        connectionOptions.cert = TlsOptionsFactory.read(tcp.tls.cert)
+        connectionOptions.key = TlsOptionsFactory.read(tcp.tls?.key ?? '')
+        connectionOptions.cert = tcp.tls?.cert ? TlsOptionsFactory.read(tcp?.tls?.cert) : undefined
       }
       if (tcp.tls.ca && tcp.tls.ca.length > 0) {
         connectionOptions.ca = tcp.tls.ca.map(i => TlsOptionsFactory.read(i))
@@ -55,6 +62,12 @@ export class TlsOptionsFactory {
       if (tcp.tls.sessionTimeout) {
         connectionOptions.sessionTimeout = tcp.tls.sessionTimeout
       }
+      if (tls.nodeTlsConnectionOptions) {
+        connectionOptions = {
+          ...connectionOptions,
+          ...tls.nodeTlsConnectionOptions
+        }
+      }
     }
     return connectionOptions
   }

package/src/transport/tcp/tls-options.ts

@@ -1,10 +1,14 @@
+import { ConnectionOptions, TlsOptions } from 'tls'
+
 export interface ITlsOptions {
-  readonly key: string,
-  readonly cert: string,
-  readonly ca?: string[],
-  readonly timeout?: number,
-  readonly sessionTimeout?: number,
-  readonly enableTrace?: boolean,
-  readonly requestCert?: boolean,
+  readonly key?: string
+  readonly cert?: string
+  readonly ca?: string[]
+  readonly timeout?: number
+  readonly sessionTimeout?: number
+  readonly enableTrace?: boolean
+  readonly requestCert?: boolean
   readonly rejectUnauthorized?: boolean
+  readonly nodeTlsConnectionOptions?: ConnectionOptions
+  readonly nodeTlsServerOptions?: TlsOptions
 }

package/src/types/FIX4.2/quickfix/advertisement.ts

@@ -0,0 +1,41 @@
+import { IStandardHeader } from './set/standard_header'
+import { IStandardTrailer } from './set/standard_trailer'
+
+export interface IAdvertisement {
+  StandardHeader: IStandardHeader// [1] BeginString.8, BodyLength.9 .. OnBehalfOfSendingTime.370
+  AdvId: string// [2] 2 (String)
+  AdvTransType: string// [3] 5 (String)
+  AdvRefID?: string// [4] 3 (String)
+  Symbol: string// [5] 55 (String)
+  SymbolSfx?: string// [6] 65 (String)
+  SecurityID?: string// [7] 48 (String)
+  IDSource?: string// [8] 22 (String)
+  SecurityType?: string// [9] 167 (String)
+  MaturityMonthYear?: string// [10] 200 (String)
+  MaturityDay?: string// [11] 205 (String)
+  PutOrCall?: number// [12] 201 (Int)
+  StrikePrice?: number// [13] 202 (Float)
+  OptAttribute?: string// [14] 206 (String)
+  ContractMultiplier?: number// [15] 231 (Float)
+  CouponRate?: number// [16] 223 (Float)
+  SecurityExchange?: string// [17] 207 (String)
+  Issuer?: string// [18] 106 (String)
+  EncodedIssuerLen?: number// [19] 348 (Length)
+  EncodedIssuer?: Buffer// [20] 349 (RawData)
+  SecurityDesc?: string// [21] 107 (String)
+  EncodedSecurityDescLen?: number// [22] 350 (Length)
+  EncodedSecurityDesc?: Buffer// [23] 351 (RawData)
+  AdvSide: string// [24] 4 (String)
+  Shares: number// [25] 53 (Float)
+  Price?: number// [26] 44 (Float)
+  Currency?: string// [27] 15 (String)
+  TradeDate?: Date// [28] 75 (LocalDate)
+  TransactTime?: Date// [29] 60 (UtcTimestamp)
+  Text?: string// [30] 58 (String)
+  EncodedTextLen?: number// [31] 354 (Length)
+  EncodedText?: Buffer// [32] 355 (RawData)
+  URLLink?: string// [33] 149 (String)
+  LastMkt?: string// [34] 30 (String)
+  TradingSessionID?: string// [35] 336 (String)
+  StandardTrailer: IStandardTrailer// [36] SignatureLength.93, Signature.89, CheckSum.10
+}

package/src/types/FIX4.2/quickfix/allocation.ts

@@ -0,0 +1,56 @@
+import { IStandardHeader } from './set/standard_header'
+import { IAllocationNoOrders } from './set/allocation_no_orders'
+import { IAllocationNoExecs } from './set/allocation_no_execs'
+import { IAllocationNoAllocs } from './set/allocation_no_allocs'
+import { IStandardTrailer } from './set/standard_trailer'
+
+export interface IAllocation {
+  StandardHeader: IStandardHeader// [1] BeginString.8, BodyLength.9 .. OnBehalfOfSendingTime.370
+  AllocID: string// [2] 70 (String)
+  AllocTransType: string// [3] 71 (String)
+  RefAllocID?: string// [4] 72 (String)
+  AllocLinkID?: string// [5] 196 (String)
+  AllocLinkType?: number// [6] 197 (Int)
+  NoOrders?: IAllocationNoOrders[]// [7] ClOrdID.11, OrderID.37 .. WaveNo.105
+  NoExecs?: IAllocationNoExecs[]// [8] LastShares.32, ExecID.17 .. LastCapacity.29
+  Side: string// [9] 54 (String)
+  Symbol: string// [10] 55 (String)
+  SymbolSfx?: string// [11] 65 (String)
+  SecurityID?: string// [12] 48 (String)
+  IDSource?: string// [13] 22 (String)
+  SecurityType?: string// [14] 167 (String)
+  MaturityMonthYear?: string// [15] 200 (String)
+  MaturityDay?: string// [16] 205 (String)
+  PutOrCall?: number// [17] 201 (Int)
+  StrikePrice?: number// [18] 202 (Float)
+  OptAttribute?: string// [19] 206 (String)
+  ContractMultiplier?: number// [20] 231 (Float)
+  CouponRate?: number// [21] 223 (Float)
+  SecurityExchange?: string// [22] 207 (String)
+  Issuer?: string// [23] 106 (String)
+  EncodedIssuerLen?: number// [24] 348 (Length)
+  EncodedIssuer?: Buffer// [25] 349 (RawData)
+  SecurityDesc?: string// [26] 107 (String)
+  EncodedSecurityDescLen?: number// [27] 350 (Length)
+  EncodedSecurityDesc?: Buffer// [28] 351 (RawData)
+  Shares: number// [29] 53 (Float)
+  LastMkt?: string// [30] 30 (String)
+  TradingSessionID?: string// [31] 336 (String)
+  AvgPx: number// [32] 6 (Float)
+  Currency?: string// [33] 15 (String)
+  AvgPrxPrecision?: number// [34] 74 (Int)
+  TradeDate: Date// [35] 75 (LocalDate)
+  TransactTime?: Date// [36] 60 (UtcTimestamp)
+  SettlmntTyp?: string// [37] 63 (String)
+  FutSettDate?: Date// [38] 64 (LocalDate)
+  GrossTradeAmt?: number// [39] 381 (Float)
+  NetMoney?: number// [40] 118 (Float)
+  OpenClose?: string// [41] 77 (String)
+  Text?: string// [42] 58 (String)
+  EncodedTextLen?: number// [43] 354 (Length)
+  EncodedText?: Buffer// [44] 355 (RawData)
+  NumDaysInterest?: number// [45] 157 (Int)
+  AccruedInterestRate?: number// [46] 158 (Float)
+  NoAllocs?: IAllocationNoAllocs[]// [47] AllocAccount.79, AllocPrice.366 .. MiscFeeType.139
+  StandardTrailer: IStandardTrailer// [48] SignatureLength.93, Signature.89, CheckSum.10
+}

package/src/types/FIX4.2/quickfix/allocation_instruction_ack.ts

@@ -0,0 +1,17 @@
+import { IStandardHeader } from './set/standard_header'
+import { IStandardTrailer } from './set/standard_trailer'
+
+export interface IAllocationInstructionAck {
+  StandardHeader: IStandardHeader// [1] BeginString.8, BodyLength.9 .. OnBehalfOfSendingTime.370
+  ClientID?: string// [2] 109 (String)
+  ExecBroker?: string// [3] 76 (String)
+  AllocID: string// [4] 70 (String)
+  TradeDate: Date// [5] 75 (LocalDate)
+  TransactTime?: Date// [6] 60 (UtcTimestamp)
+  AllocStatus: number// [7] 87 (Int)
+  AllocRejCode?: number// [8] 88 (Int)
+  Text?: string// [9] 58 (String)
+  EncodedTextLen?: number// [10] 354 (Length)
+  EncodedText?: Buffer// [11] 355 (RawData)
+  StandardTrailer: IStandardTrailer// [12] SignatureLength.93, Signature.89, CheckSum.10
+}

package/src/types/FIX4.2/quickfix/bid_request.ts

@@ -0,0 +1,38 @@
+import { IStandardHeader } from './set/standard_header'
+import { IBidRequestNoBidDescriptors } from './set/bid_request_no_bid_descriptors'
+import { IBidRequestNoBidComponents } from './set/bid_request_no_bid_components'
+import { IStandardTrailer } from './set/standard_trailer'
+
+export interface IBidRequest {
+  StandardHeader: IStandardHeader// [1] BeginString.8, BodyLength.9 .. OnBehalfOfSendingTime.370
+  BidID?: string// [2] 390 (String)
+  ClientBidID: string// [3] 391 (String)
+  BidRequestTransType: string// [4] 374 (String)
+  ListName?: string// [5] 392 (String)
+  TotalNumSecurities: number// [6] 393 (Int)
+  BidType: number// [7] 394 (Int)
+  NumTickets?: number// [8] 395 (Int)
+  Currency?: string// [9] 15 (String)
+  SideValue1?: number// [10] 396 (Float)
+  SideValue2?: number// [11] 397 (Float)
+  NoBidDescriptors?: IBidRequestNoBidDescriptors[]// [12] BidDescriptorType.399, BidDescriptor.400 .. ValueOfFutures.408
+  NoBidComponents?: IBidRequestNoBidComponents[]// [13] ListID.66, Side.54 .. Account.1
+  LiquidityIndType?: number// [14] 409 (Int)
+  WtAverageLiquidity?: number// [15] 410 (Float)
+  ExchangeForPhysical?: boolean// [16] 411 (Boolean)
+  OutMainCntryUIndex?: number// [17] 412 (Float)
+  CrossPercent?: number// [18] 413 (Float)
+  ProgRptReqs?: number// [19] 414 (Int)
+  ProgPeriodInterval?: number// [20] 415 (Int)
+  IncTaxInd?: number// [21] 416 (Int)
+  ForexReq?: boolean// [22] 121 (Boolean)
+  NumBidders?: number// [23] 417 (Int)
+  TradeDate?: Date// [24] 75 (LocalDate)
+  TradeType: string// [25] 418 (String)
+  BasisPxType: string// [26] 419 (String)
+  StrikeTime?: Date// [27] 443 (UtcTimestamp)
+  Text?: string// [28] 58 (String)
+  EncodedTextLen?: number// [29] 354 (Length)
+  EncodedText?: Buffer// [30] 355 (RawData)
+  StandardTrailer: IStandardTrailer// [31] SignatureLength.93, Signature.89, CheckSum.10
+}

package/src/types/FIX4.2/quickfix/bid_response.ts

@@ -0,0 +1,11 @@
+import { IStandardHeader } from './set/standard_header'
+import { IBidResponseNoBidComponents } from './set/bid_response_no_bid_components'
+import { IStandardTrailer } from './set/standard_trailer'
+
+export interface IBidResponse {
+  StandardHeader: IStandardHeader// [1] BeginString.8, BodyLength.9 .. OnBehalfOfSendingTime.370
+  BidID?: string// [2] 390 (String)
+  ClientBidID?: string// [3] 391 (String)
+  NoBidComponents: IBidResponseNoBidComponents[]// [4] Commission.12, CommType.13 .. EncodedText.355
+  StandardTrailer: IStandardTrailer// [5] SignatureLength.93, Signature.89, CheckSum.10
+}

package/src/types/FIX4.2/quickfix/business_message_reject.ts

@@ -0,0 +1,14 @@
+import { IStandardHeader } from './set/standard_header'
+import { IStandardTrailer } from './set/standard_trailer'
+
+export interface IBusinessMessageReject {
+  StandardHeader: IStandardHeader// [1] BeginString.8, BodyLength.9 .. OnBehalfOfSendingTime.370
+  RefSeqNum?: number// [2] 45 (Int)
+  RefMsgType: string// [3] 372 (String)
+  BusinessRejectRefID?: string// [4] 379 (String)
+  BusinessRejectReason: number// [5] 380 (Int)
+  Text?: string// [6] 58 (String)
+  EncodedTextLen?: number// [7] 354 (Length)
+  EncodedText?: Buffer// [8] 355 (RawData)
+  StandardTrailer: IStandardTrailer// [9] SignatureLength.93, Signature.89, CheckSum.10
+}