@seriousme/opifex 2.0.3 → 2.2.0

package/mqttPacket/ReasonCode.ts

@@ -227,14 +227,12 @@ const reasonCodesToString = {
   [0xa2]: "Wildcard Subscriptions not supported",
 } as const;
 
-// Can't import this from types as this would create an import loop
-type TPacketType = typeof PacketType[keyof typeof PacketType];
-export type TReasonCode = typeof ReasonCode[keyof typeof ReasonCode];
-type TReasonCodeByPacket = keyof typeof ReasonCodebyPacket;
+export type ReasonCode = typeof ReasonCode[keyof typeof ReasonCode];
+type ReasonCodeByPacket = keyof typeof ReasonCodebyPacket;
 
 export function reasonCodeToString(
-  packetType: TPacketType,
-  code: TReasonCode,
+  packetType: PacketType,
+  code: ReasonCode,
 ): string {
   if (code === 0) {
     if (packetType === PacketType.disconnect) {
@@ -248,10 +246,10 @@ export function reasonCodeToString(
 }
 
 export function isValidReasonCode(
-  packetType: TPacketType,
+  packetType: PacketType,
   code: number,
 ): boolean {
   const validReasonCodes =
-    ReasonCodebyPacket[packetType as TReasonCodeByPacket] as readonly number[];
+    ReasonCodebyPacket[packetType as ReasonCodeByPacket] as readonly number[];
   return validReasonCodes.includes(code);
 }

package/mqttPacket/RetainHandling.ts

@@ -9,3 +9,8 @@ export const RetainHandling = {
   ifSubscriptionNotExists: 1,
   noRetain: 2,
 } as const;
+
+/**
+ * helper type to limit retain handling values
+ */
+export type RetainHandling = typeof RetainHandling[keyof typeof RetainHandling];

package/mqttPacket/auth.ts

@@ -1,16 +1,16 @@
 import { PacketType } from "./PacketType.ts";
 import { Encoder, EncoderError } from "./encoder.ts";
 import { Decoder, DecoderError, hasEmptyFlags } from "./decoder.ts";
-import type { TReasonCode } from "./ReasonCode.ts";
+import type { ReasonCode } from "./ReasonCode.ts";
 import type { AuthProperties } from "./Properties.ts";
-import type { CodecOpts, TPacketType } from "./types.ts";
+import type { CodecOpts } from "./types.ts";
 import { MQTTLevel } from "./protocolLevels.ts";
 
 // AuthPacket does not exist on protocol levels < 5
 export type AuthPacketV5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
-  reasonCode: TReasonCode;
+  reasonCode: ReasonCode;
   properties?: AuthProperties;
 };
 
@@ -30,7 +30,7 @@ export function encode(packet: AuthPacket, codecOpts: CodecOpts): Uint8Array {
   // deno-coverage-ignore-stop
   const encoder = new Encoder(packet.type);
   encoder
-    .setReasonCode(packet.reasonCode || 0)
+    .seReasonCode(packet.reasonCode || 0)
     .setProperties(
       packet.properties || {},
       packet.type,
@@ -43,7 +43,7 @@ export function decode(
   buffer: Uint8Array,
   flags: number,
   codecOpts: CodecOpts,
-  packetType: TPacketType,
+  packetType: PacketType,
 ): AuthPacket {
   // Bits 3,2,1 and 0 of the Fixed Header of the AUTH packet are reserved and MUST all be set to 0.
   // The Client or Server MUST treat any other value as malformed and close the Network Connection [MQTT-3.15.1-1].
@@ -52,7 +52,7 @@ export function decode(
     throw new DecoderError("Invalid protocol level");
   }
   const decoder = new Decoder(packetType, buffer);
-  const reasonCode = decoder.getReasonCode();
+  const reasonCode = decoder.geReasonCode();
   const properties = decoder.getProperties(PacketType.auth);
   decoder.done();
   return {

package/mqttPacket/codec.ts

@@ -1,4 +1,5 @@
-import type { CodecOpts, TPacketType } from "./types.ts";
+import type { CodecOpts } from "./types.ts";
+import type { PacketType } from "./PacketType.ts";
 import { DecoderError } from "./decoder.ts";
 import { decodeLength } from "./length.ts";
 
@@ -117,7 +118,7 @@ export function decodePayload(
     buffer,
     flags,
     codecOpts,
-    packetType as TPacketType,
+    packetType as PacketType,
   );
   if (packet !== undefined) {
     return packet;

package/mqttPacket/connack.ts

@@ -1,4 +1,4 @@
-import type { CodecOpts, TAuthenticationResult, TPacketType } from "./types.ts";
+import type { CodecOpts } from "./types.ts";
 import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import { PacketType } from "./PacketType.ts";
 import { BitMask } from "./BitMask.ts";
@@ -10,21 +10,22 @@ import {
   hasEmptyFlags,
 } from "./decoder.ts";
 import { AuthenticationResultByNumber } from "./AuthenticationResult.ts";
-import type { TReasonCode } from "./ReasonCode.ts";
+import type { AuthenticationResult } from "./AuthenticationResult.ts";
+import type { ReasonCode } from "./ReasonCode.ts";
 import type { ConnackProperties } from "./Properties.ts";
 
 export type ConnackPacketV4 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevelNoV5;
   sessionPresent: boolean;
-  returnCode: TAuthenticationResult;
+  returnCode: AuthenticationResult;
 };
 
 export type ConnackPacketV5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
   sessionPresent: boolean;
-  reasonCode: TReasonCode;
+  reasonCode: ReasonCode;
   properties?: ConnackProperties;
 };
 
@@ -49,7 +50,7 @@ export function encode(
   const encoder = new Encoder(packet.type);
   encoder
     .setByte(packet.sessionPresent ? 1 : 0)
-    .setReasonCode(packet.reasonCode || 0)
+    .seReasonCode(packet.reasonCode || 0)
     .setProperties(
       packet.properties || {},
       packet.type,
@@ -62,7 +63,7 @@ export function decode(
   buffer: Uint8Array,
   flags: number,
   codecOpts: CodecOpts,
-  packetType: TPacketType,
+  packetType: PacketType,
 ): ConnackPacket {
   const decoder = new Decoder(packetType, buffer);
   hasEmptyFlags(flags);
@@ -72,7 +73,7 @@ export function decode(
   }
   const sessionPresent = booleanFlag(ackflags, BitMask.bit0);
   if (codecOpts.protocolLevel !== 5) {
-    const returnCode = decoder.getByte() as TAuthenticationResult;
+    const returnCode = decoder.getByte() as AuthenticationResult;
     decoder.done();
     if (!AuthenticationResultByNumber[returnCode]) {
       throw new DecoderError("Invalid return code");
@@ -84,7 +85,7 @@ export function decode(
       returnCode,
     };
   }
-  const reasonCode = decoder.getReasonCode();
+  const reasonCode = decoder.geReasonCode();
   const properties = decoder.getProperties(PacketType.connack);
   decoder.done();
   return {

package/mqttPacket/connect.ts

@@ -1,11 +1,4 @@
-import type {
-  ClientId,
-  CodecOpts,
-  Payload,
-  QoS,
-  Topic,
-  TPacketType,
-} from "./types.ts";
+import type { ClientId, CodecOpts, Payload, QoS, Topic } from "./types.ts";
 import type { ProtocolLevel, ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { ConnectProperties, WillProperties } from "./Properties.ts";
 import { PropertySetType } from "./Properties.ts";
@@ -20,7 +13,7 @@ import {
 } from "./decoder.ts";
 
 export type ConnectPacketV4 = {
-  type: TPacketType;
+  type: PacketType;
   protocolName?: string | undefined;
   protocolLevel: ProtocolLevelNoV5;
   clientId?: ClientId | undefined;
@@ -38,7 +31,7 @@ export type ConnectPacketV4 = {
 };
 
 export type ConnectPacketV5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolName?: string | undefined;
   protocolLevel: 5;
   clientId?: ClientId | undefined;
@@ -167,7 +160,7 @@ export function decode(
   buffer: Uint8Array,
   flags: number,
   _codecOpts: CodecOpts,
-  packetType: TPacketType,
+  packetType: PacketType,
 ): ConnectPacket {
   const decoder = new Decoder(packetType, buffer);
   const protocolName = decoder.getUTF8String();

package/mqttPacket/decoder.ts

@@ -1,9 +1,4 @@
-import type {
-  TBitMask,
-  TPacketType,
-  TReasonCode,
-  UTF8StringPair,
-} from "./types.ts";
+import type { BitMask, UTF8StringPair } from "./types.ts";
 import { invalidUTF8 } from "./validators.ts";
 import { isValidReasonCode } from "./ReasonCode.ts";
 import type {
@@ -21,6 +16,9 @@ import {
   propertyToKind,
 } from "./Properties.ts";
 
+import type { PacketType } from "./PacketType.ts";
+import type { ReasonCode } from "./ReasonCode.ts";
+
 const utf8Decoder = new TextDecoder("utf-8");
 const userPropID = propertyToId.userProperty;
 const subIdentID = propertyToId.subscriptionIdentifier;
@@ -31,7 +29,7 @@ const subIdentsID = propertyToId.subscriptionIdentifiers;
  * @param mask - The bitmask to apply
  * @returns True if the flag is set, false otherwise
  */
-export function booleanFlag(byte: number, mask: TBitMask): boolean {
+export function booleanFlag(byte: number, mask: BitMask): boolean {
   return !!(byte & mask);
 }
 
@@ -71,7 +69,7 @@ export class DecoderError extends Error {
  * Decoder class for parsing MQTT packets
  */
 export class Decoder {
-  private packetType: TPacketType;
+  private packetType: PacketType;
   private buf: Uint8Array;
   private pos: number;
   private len: number;
@@ -81,7 +79,7 @@ export class Decoder {
    * @param buf - The buffer to decode
    * @param pos - Starting position in the buffer (default: 0)
    */
-  constructor(packetType: TPacketType, buf: Uint8Array, pos: number = 0) {
+  constructor(packetType: PacketType, buf: Uint8Array, pos: number = 0) {
     this.packetType = packetType;
     this.buf = buf;
     this.pos = pos;
@@ -289,12 +287,12 @@ export class Decoder {
    * @returns The decoded reason code
    * @throws {DecoderError} If reason code is invalid
    */
-  getReasonCode(): TReasonCode {
+  geReasonCode(): ReasonCode {
     const reasonCode = this.getByte();
     if (!isValidReasonCode(this.packetType, reasonCode)) {
       throw new DecoderError("Invalid reason code");
     }
-    return reasonCode as TReasonCode;
+    return reasonCode as ReasonCode;
   }
 
   /**

package/mqttPacket/disconnect.ts

@@ -1,20 +1,20 @@
 import { PacketType } from "./PacketType.ts";
 import { Decoder, hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
-import type { CodecOpts, TPacketType, TReasonCode } from "./types.ts";
+import type { CodecOpts } from "./types.ts";
 import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { DisconnectProperties } from "./Properties.ts";
 import { Encoder } from "./encoder.ts";
 import { ReasonCode } from "./ReasonCode.ts";
 
 export type DisconnectPacketv4 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevelNoV5;
 };
 
 export type DisconnectPacketv5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
-  reasonCode: TReasonCode;
+  reasonCode: ReasonCode;
   properties?: DisconnectProperties;
 };
 
@@ -44,7 +44,7 @@ export function encode(
     return encoder.done(0);
   }
   encoder
-    .setReasonCode(reasonCode);
+    .seReasonCode(reasonCode);
   if (packet.properties) {
     encoder.setProperties(
       packet.properties,
@@ -59,7 +59,7 @@ export function decode(
   buffer: Uint8Array,
   flags: number,
   codecOpts: CodecOpts,
-  packetType: TPacketType,
+  packetType: PacketType,
 ): DisconnectPacket {
   hasEmptyFlags(flags);
   if (codecOpts.protocolLevel !== 5) {
@@ -77,7 +77,7 @@ export function decode(
       reasonCode: 0,
     };
   }
-  const reasonCode = decoder.getReasonCode();
+  const reasonCode = decoder.geReasonCode();
   const properties = decoder.getProperties(PacketType.disconnect);
   decoder.done();
   return {

package/mqttPacket/encoder.test.ts

@@ -51,13 +51,13 @@ test("encode string", () => {
 test("encode reasonCode", () => {
   const reasonCode = ReasonCode.success;
   const encoder = new Encoder(PacketType.connack);
-  encoder.setReasonCode(reasonCode);
+  encoder.seReasonCode(reasonCode);
   assert.deepStrictEqual(encoder.done(0), new Uint8Array([32, 1, reasonCode]));
 });
 
 test("encode invalid reasonCode", () => {
   const encoder = new Encoder(PacketType.connack);
   assert.throws(() => {
-    encoder.setReasonCode(ReasonCode.noMatchingSubscribers);
+    encoder.seReasonCode(ReasonCode.noMatchingSubscribers);
   }, /Reason code 16 not allowed for packet type 2/);
 });

package/mqttPacket/encoder.ts

@@ -1,10 +1,10 @@
-import type { TPacketType, TReasonCode, UTF8StringPair } from "./types.ts";
+import type { UTF8StringPair } from "./types.ts";
 
 import type {
   Mqttv5PropertyTypes,
+  PropertySetType,
   PropsByPacketSetType,
   SubscriptionIdentifiersType,
-  TPropertySetType,
   UserPropertyType,
   ValidPropertyNumber,
 } from "./Properties.ts";
@@ -17,6 +17,8 @@ import {
   propertyToKind,
 } from "./Properties.ts";
 
+import type { PacketType } from "./PacketType.ts";
+import type { ReasonCode } from "./ReasonCode.ts";
 import { encodeLength } from "./length.ts";
 import { invalidUTF8 } from "./validators.ts";
 import { isValidReasonCode } from "./ReasonCode.ts";
@@ -44,7 +46,7 @@ export class Encoder {
   private numBytes: number;
 
   /** Packet type */
-  private packetType: TPacketType;
+  private packetType: PacketType;
 
   /** marker to rewind to */
   private marker: number;
@@ -52,7 +54,7 @@ export class Encoder {
   /**
    * Creates a new Encoder instance
    */
-  constructor(packetType: TPacketType) {
+  constructor(packetType: PacketType) {
     this.buffers = [];
     this.numBytes = 0;
     this.packetType = packetType;
@@ -253,9 +255,9 @@ export class Encoder {
    * @param propertySetType - the type of packet to encode for
    * @param maximumPacketSize - the maximum packet size to be consumed by properties
    */
-  setProperties<T extends TPropertySetType>(
+  setProperties<T extends PropertySetType>(
     props: PropsByPacketSetType[T],
-    propertySetType: TPropertySetType,
+    propertySetType: PropertySetType,
     maximumPacketSize: number,
   ) {
     const propsEncoder = new Encoder(0);
@@ -282,7 +284,7 @@ export class Encoder {
     propsEncoder.addToEncoder(this);
   }
 
-  setReasonCode(reasonCode: TReasonCode) {
+  seReasonCode(reasonCode: ReasonCode) {
     if (!isValidReasonCode(this.packetType, reasonCode)) {
       throw new EncoderError(
         `Reason code ${reasonCode} not allowed for packet type ${this.packetType}`,

package/mqttPacket/mod.ts

@@ -51,12 +51,8 @@ export type {
   Payload,
   QoS,
   ReturnCodes,
-  TAuthenticationResult,
   Topic,
   TopicFilter,
-  TPacketType,
-  TReasonCode,
-  TRetainHandling,
   UTF8StringPair,
 } from "./types.ts";
 

package/mqttPacket/pingreq.ts

@@ -1,13 +1,13 @@
 import { PacketType } from "./PacketType.ts";
 import { hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
-import type { CodecOpts, TPacketType } from "./types.ts";
+import type { CodecOpts } from "./types.ts";
 import type { ProtocolLevel } from "./protocolLevels.ts";
 
 /**
  * PingreqPacket is a packet that is sent to the server to keep the connection alive
  */
 export type PingreqPacket = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevel;
 };
 
@@ -24,7 +24,7 @@ export function decode(
   buffer: Uint8Array,
   flags: number,
   codecOpts: CodecOpts,
-  _packetType: TPacketType,
+  _packetType: PacketType,
 ): PingreqPacket {
   hasEmptyFlags(flags);
   isEmptyBuf(buffer);

package/mqttPacket/pingres.ts

@@ -1,6 +1,6 @@
 import { PacketType } from "./PacketType.ts";
 import { hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
-import type { CodecOpts, TPacketType } from "./types.ts";
+import type { CodecOpts } from "./types.ts";
 import type { ProtocolLevel } from "./protocolLevels.ts";
 
 /**
@@ -8,7 +8,7 @@ import type { ProtocolLevel } from "./protocolLevels.ts";
  * It is used to indicate that the client is still connected to the server.
  */
 export type PingresPacket = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevel;
 };
 
@@ -25,7 +25,7 @@ export function decode(
   buffer: Uint8Array,
   flags: number,
   codecOpts: CodecOpts,
-  _packetType: TPacketType,
+  _packetType: PacketType,
 ): PingresPacket {
   hasEmptyFlags(flags);
   isEmptyBuf(buffer);

package/mqttPacket/protocolLevels.ts

@@ -14,5 +14,7 @@ export const MQTTLevel = {
   v5: 5,
 } as const;
 
+/** the MQTT protocol level: 3, 4, 5 or undefined */
 export type ProtocolLevel = (typeof MQTTLevel)[keyof typeof MQTTLevel];
+/** all MQTT protocol levels except 5 */
 export type ProtocolLevelNoV5 = Exclude<ProtocolLevel, 5>;

package/mqttPacket/pubblishAcks.ts

@@ -1,29 +1,29 @@
-import type { CodecOpts, PacketId, TPacketType } from "./types.ts";
+import type { CodecOpts, PacketId } from "./types.ts";
 import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
-import { ReasonCode, type TReasonCode } from "./ReasonCode.ts";
+import { ReasonCode } from "./ReasonCode.ts";
 import type { PubackProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { Decoder, DecoderError } from "./decoder.ts";
 import { Encoder } from "./encoder.ts";
 
-export type AckPacketV4<T extends TPacketType> = {
+export type AckPacketV4<T extends PacketType> = {
   type: T;
   protocolLevel: ProtocolLevelNoV5;
   id: PacketId;
 };
 
-export type AckPacketV5<T extends TPacketType> = {
+export type AckPacketV5<T extends PacketType> = {
   type: T;
   protocolLevel: 5;
   id: PacketId;
-  reasonCode?: TReasonCode;
+  reasonCode?: ReasonCode;
   properties?: PubackProperties;
 };
 
 /**
  * all 4 ack packets are identical except for packet type and flags of Pubrel
  */
-export type AckPacket<T extends TPacketType> = AckPacketV4<T> | AckPacketV5<T>;
+export type AckPacket<T extends PacketType> = AckPacketV4<T> | AckPacketV5<T>;
 
 /**
  * PubackPacket is sent to indicate publish complete (QoS 1)
@@ -64,7 +64,7 @@ export function encode(packet: AnyAckPacket, codecOpts: CodecOpts): Uint8Array {
     ) {
       return encoder.done(flags);
     }
-    encoder.setReasonCode(reasonCode);
+    encoder.seReasonCode(reasonCode);
     encoder.setProperties(
       packet.properties || {},
       packet.type,
@@ -78,7 +78,7 @@ export function decode(
   buffer: Uint8Array,
   flags: number,
   codecOpts: CodecOpts,
-  packetType: TPacketType,
+  packetType: PacketType,
 ): AnyAckPacket {
   const expectedFlags = packetType === PacketType.pubrel ? 2 : 0;
   if (flags !== expectedFlags) {
@@ -102,7 +102,7 @@ export function decode(
       reasonCode: 0,
     } as AnyAckPacket;
   }
-  const reasonCode = decoder.getReasonCode();
+  const reasonCode = decoder.geReasonCode();
   const properties = decoder.getProperties(packetType);
   return {
     type: packetType as AnyAckPacket["type"],

package/mqttPacket/publish.ts

@@ -1,11 +1,4 @@
-import type {
-  CodecOpts,
-  Dup,
-  Payload,
-  QoS,
-  Topic,
-  TPacketType,
-} from "./types.ts";
+import type { CodecOpts, Dup, Payload, QoS, Topic } from "./types.ts";
 import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { PublishProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
@@ -18,7 +11,7 @@ import { booleanFlag, Decoder, DecoderError } from "./decoder.ts";
  * from server to subscribers
  */
 export type PublishPacketV4 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevelNoV5;
   topic: Topic;
   payload: Payload;
@@ -28,7 +21,7 @@ export type PublishPacketV4 = {
   id?: number | undefined;
 };
 export type PublishPacketV5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
   topic: Topic;
   payload: Payload;
@@ -77,7 +70,7 @@ export function decode(
   buffer: Uint8Array,
   flags: number,
   codecOpts: CodecOpts,
-  packetType: TPacketType,
+  packetType: PacketType,
 ): PublishPacket {
   const dup = booleanFlag(flags, BitMask.bit3);
   const qos = (flags & 6) >> 1;

package/mqttPacket/publishAcks.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { test } from "node:test";
 
 import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
-import type { CodecOpts, TPacketType, TReasonCode } from "./mod.ts";
+import type { CodecOpts } from "./mod.ts";
 
 const codecOptsV4: CodecOpts = {
   protocolLevel: MQTTLevel.v4,
@@ -24,9 +24,9 @@ const packetTypesToTest = [
 ];
 for (const item of packetTypesToTest) {
   const [ackType, label, reasonCode] = item as [
-    TPacketType,
+    PacketType,
     string,
-    TReasonCode,
+    ReasonCode,
   ];
   const ackTypeByte = (ackType << 4) + (ackType === PacketType.pubrel ? 2 : 0);
   test(`encode/decode ${label} v4`, () => {

package/mqttPacket/suback.ts

@@ -1,10 +1,5 @@
-import type {
-  CodecOpts,
-  PacketId,
-  ReturnCodes,
-  TPacketType,
-  TReasonCode,
-} from "./types.ts";
+import type { CodecOpts, PacketId, ReturnCodes } from "./types.ts";
+import type { ReasonCode } from "./ReasonCode.ts";
 import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { SubackProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
@@ -13,18 +8,18 @@ import { Decoder, DecoderError } from "./decoder.ts";
 const validReturnCodes = [0x00, 0x01, 0x02, 0x80];
 
 export type SubackPacketV4 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevelNoV5;
   id: PacketId;
   returnCodes: ReturnCodes;
 };
 
 export type SubackPacketV5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
   id: PacketId;
   properties: SubackProperties;
-  reasonCodes: Array<TReasonCode>;
+  reasonCodes: Array<ReasonCode>;
 };
 
 /**
@@ -52,7 +47,7 @@ export function encode(packet: SubackPacket, codecOpts: CodecOpts): Uint8Array {
     codecOpts.maxOutgoingPacketSize,
   );
   for (const code of packet.reasonCodes) {
-    encoder.setReasonCode(code);
+    encoder.seReasonCode(code);
   }
   return encoder.done(flags);
 }
@@ -61,7 +56,7 @@ export function decode(
   buffer: Uint8Array,
   _flags: number,
   codecOpts: CodecOpts,
-  packetType: TPacketType,
+  packetType: PacketType,
 ): SubackPacket {
   const packet = {} as SubackPacket;
   const decoder = new Decoder(packetType, buffer);
@@ -83,7 +78,7 @@ export function decode(
   packet.properties = decoder.getProperties(PacketType.suback);
   packet.reasonCodes = [];
   while (!decoder.atEnd()) {
-    const code = decoder.getReasonCode();
+    const code = decoder.geReasonCode();
     packet.reasonCodes.push(code);
   }
   return packet;