amf-ts 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,795 @@
+/**
+ * AMF0 类型定义
+ *
+ * AMF0 是 AMF 协议的第一个版本
+ * 支持基本的数据类型如数字、字符串、对象、数组等
+ */
+export declare const AMF0: {
+    /**
+     * 根据 JavaScript 值推断对应的 AMF0 类型
+     *
+     * @param value - 要推断类型的值
+     * @returns 对应的 AMF0 类型
+     * @throws 如果无法推断类型则抛出错误
+     */
+    infer(value: any): AMFType;
+    /**
+     * 根据类型 ID 获取对应的 AMF0 类型
+     *
+     * @param id - 类型的数字标识符
+     * @returns 对应的 AMF0 类型
+     * @throws 如果找不到对应的类型则抛出错误
+     */
+    fromId(id: number): AMFType;
+    /** 数字类型 (0x00) - 64位双精度浮点数 */
+    NUMBER: AMFType;
+    /** 布尔类型 (0x01) */
+    BOOLEAN: AMFType;
+    /** 字符串类型 (0x02) - 最大 65535 字节 */
+    STRING: AMFType;
+    /** 对象类型 (0x03) - 匿名对象 */
+    OBJECT: AMFType;
+    /** MovieClip 类型 (0x04) - Flash 专用，通常不使用 */
+    MOVIECLIP: AMFType;
+    /** 空值类型 (0x05) */
+    NULL: AMFType;
+    /** 未定义类型 (0x06) */
+    UNDEFINED: AMFType;
+    /** 引用类型 (0x07) - 引用之前序列化的对象 */
+    REFERENCE: AMFType;
+    /** ECMA 数组类型 (0x08) - 关联数组/对象 */
+    ECMA_ARRAY: AMFType;
+    /** 对象结束标记 (0x09) */
+    OBJECT_END: AMFType;
+    /** 严格数组类型 (0x0A) - 数字索引数组 */
+    STRICT_ARRAY: AMFType;
+    /** 日期类型 (0x0B) */
+    DATE: AMFType;
+    /** 长字符串类型 (0x0C) - 超过 65535 字节的字符串 */
+    LONG_STRING: AMFType;
+    /** 不支持的类型 (0x0D) */
+    UNSUPPORTED: AMFType;
+    /** XML 类型 (0x0F) */
+    XML: AMFType;
+    /** 类型化对象 (0x10) - 有类名的对象 */
+    TYPED_OBJECT: AMFType;
+    /** AMF3 对象标记 (0x11) - 表示后续数据使用 AMF3 格式 */
+    AMF3_OBJECT: AMFType;
+};
+
+/**
+ * AMF3 类型定义
+ *
+ * AMF3 是 AMF 协议的第三个版本（跳过了 AMF2）
+ * 相比 AMF0，它更加紧凑，支持更多的数据类型
+ * 包括字节数组、向量等
+ */
+export declare const AMF3: {
+    /**
+     * 根据 JavaScript 值推断对应的 AMF3 类型
+     *
+     * @param value - 要推断类型的值
+     * @returns 对应的 AMF3 类型
+     * @throws 如果无法推断类型则抛出错误
+     */
+    infer(value: any): AMFType;
+    /**
+     * 根据类型 ID 获取对应的 AMF3 类型
+     *
+     * @param id - 类型的数字标识符
+     * @returns 对应的 AMF3 类型
+     * @throws 如果找不到对应的类型则抛出错误
+     */
+    fromId(id: number): AMFType;
+    /** 未定义类型 (0x00) */
+    UNDEFINED: AMFType;
+    /** 空值类型 (0x01) */
+    NULL: AMFType;
+    /** 布尔假值 (0x02) */
+    FALSE: AMFType;
+    /** 布尔真值 (0x03) */
+    TRUE: AMFType;
+    /** 整数类型 (0x04) - 29位有符号整数 */
+    INTEGER: AMFType;
+    /** 双精度浮点数类型 (0x05) */
+    DOUBLE: AMFType;
+    /** 字符串类型 (0x06) */
+    STRING: AMFType;
+    /** XML 文档类型 (0x07) */
+    XML_DOC: AMFType;
+    /** 日期类型 (0x08) */
+    DATE: AMFType;
+    /** 数组类型 (0x09) */
+    ARRAY: AMFType;
+    /** 对象类型 (0x0A) */
+    OBJECT: AMFType;
+    /** XML 类型 (0x0B) */
+    XML: AMFType;
+    /** 字节数组类型 (0x0C) */
+    BYTE_ARRAY: AMFType;
+    /** 整数向量类型 (0x0D) */
+    VECTOR_INT: AMFType;
+    /** 无符号整数向量类型 (0x0E) */
+    VECTOR_UINT: AMFType;
+    /** 双精度浮点数向量类型 (0x0F) */
+    VECTOR_DOUBLE: AMFType;
+    /** 对象向量类型 (0x10) */
+    VECTOR_OBJECT: AMFType;
+    /** 字典类型 (0x11) */
+    DICTIONARY: AMFType;
+};
+
+/**
+ * AMF3 解码器
+ */
+export declare class AMFDecoder extends Reader {
+    /** AMF3 外部化对象注册表 */
+    static amf3Externalizables: Record<string, ExternalizableReader>;
+    /** AMF3 字符串引用表 */
+    private amf3StringReferences;
+    /** AMF3 对象引用表 */
+    private amf3ObjectReferences;
+    /** AMF3 Trait 引用表 */
+    private amf3TraitReferences;
+    /**
+     * 注册外部化类型
+     */
+    static register(className: string, cls: ExternalizableReader): void;
+    constructor(data: Uint8Array);
+    /**
+     * 解码一个 AMF3 值
+     */
+    decode(): any;
+    /**
+     * 按 AMF3 类型对象解码（兼容接口）
+     */
+    deserialize(type: number | AMFType): any;
+    /**
+     * 按类型 ID 分发解码
+     */
+    private readByTypeId;
+    /**
+     * 读取 AMF3 字符串
+     *
+     * todo 字符串过长时可能有bug?  当前读长读，用的是u29的方式
+     */
+    private readAMF3String;
+    /**
+     * 读取 AMF3 日期
+     */
+    private readAMF3Date;
+    /**
+     * 读取 AMF3 数组
+     */
+    private readAMF3Array;
+    /**
+     * 读取 AMF3 对象 Trait
+     */
+    private readAMF3ObjectTrait;
+    /**
+     * 读取 AMF3 对象
+     */
+    private readAMF3Object;
+    /**
+     * 读取 AMF3 ByteArray
+     */
+    private readAMF3ByteArray;
+    /**
+     * 向量解码通用逻辑
+     */
+    private readAMF3Vector;
+    /**
+     * 读取 VECTOR_INT
+     */
+    private readAMF3VectorInt;
+    /**
+     * 读取 VECTOR_UINT
+     */
+    private readAMF3VectorUInt;
+    /**
+     * 读取 VECTOR_DOUBLE
+     */
+    private readAMF3VectorDouble;
+    /**
+     * 读取 VECTOR_OBJECT
+     */
+    private readAMF3VectorObject;
+    /**
+     * 读取 DICTIONARY
+     */
+    private readAMF3Dictionary;
+}
+
+/**
+ * AMF3 编码器
+ */
+export declare class AMFEncoder extends Writer {
+    /** AMF3 对象引用表 */
+    private amf3ObjectReferences;
+    /** AMF3 字符串引用表 */
+    private amf3StringReferences;
+    constructor();
+    /**
+     * 编码一个 AMF3 值（会写入类型标记）
+     */
+    writeObject(value: any): void;
+    /**
+     * 兼容旧接口，含义与 writeObject 相同
+     */
+    encode(value: any): void;
+    /**
+     * 编码值主体（无类型标记）
+     */
+    serialize(value: any): void;
+    /**
+     * 推断值的 AMF3 类型
+     */
+    private inferType;
+    /**
+     * 编码一个完整值（含类型标记与引用处理）
+     */
+    private encodeValue;
+    /**
+     * 按类型写入值主体（不包含类型标记）
+     */
+    private writeByType;
+    /**
+     * 写入 AMF3 内联字符串（无类型标记）
+     *
+     * 说明：
+     * 这里保持与原 lib 行为一致，不在“无类型字符串”分支中做字符串引用表复用。
+     */
+    private writeInlineString;
+    /**
+     * 写入 AMF3 数组（密集数组或关联数组）
+     */
+    private writeArray;
+    /**
+     * 写入 AMF3 对象
+     */
+    private writeObjectValue;
+    /**
+     * 写入 AMF3 ByteArray
+     */
+    private writeByteArray;
+}
+
+/**
+ * 二进制数据读取器模块
+ *
+ * 本模块提供了从二进制数据中读取各种数据类型的功能
+ * 专为浏览器环境设计，使用 Uint8Array 和 DataView 替代 Node.js 的 Buffer
+ */
+/**
+ * AMF 头部信息接口
+ *
+ * 在 AMF3 中，许多类型使用一个特殊的头部来表示是定义还是引用
+ */
+declare interface AMFHeader {
+    /** 是否是定义（true）还是引用（false） */
+    isDef: boolean;
+    /** 头部的值（引用索引或数据长度） */
+    value: number;
+}
+
+/**
+ * AMF3 对象特征类
+ *
+ * 用于描述 AMF3 对象的元数据信息
+ * 包括类名、是否为动态对象、是否可外部化、以及静态字段列表
+ *
+ * 在 AMF3 中，对象特征可以被引用以减少数据大小
+ * 当多个相同类型的对象被序列化时，只需要序列化一次特征信息
+ */
+export declare class AMFTrait {
+    /** 对象的类名（可以为空表示匿名对象） */
+    name: string;
+    /**
+     * 是否为动态对象
+     * 动态对象可以有任意的属性，而非动态对象只能有预定义的静态属性
+     */
+    dynamic: boolean;
+    /**
+     * 是否可外部化
+     * 可外部化对象需要自己控制序列化和反序列化过程
+     */
+    externalizable: boolean;
+    /** 静态字段名列表 */
+    staticFields: string[];
+    /**
+     * 创建一个 AMF3 对象特征
+     *
+     * @param name - 对象的类名
+     * @param dynamic - 是否为动态对象
+     * @param externalizable - 是否可外部化
+     */
+    constructor(name: string, dynamic: boolean, externalizable: boolean);
+}
+
+/**
+ * AMF 类型定义模块
+ *
+ * 本模块定义了 AMF0 和 AMF3 协议中所有的数据类型
+ * AMF (Action Message Format) 是 Adobe 开发的一种二进制数据序列化格式
+ * 主要用于 Flash/Flex 应用与服务器之间的数据交换
+ */
+/**
+ * AMF 类型基类
+ *
+ * 每种 AMF 数据类型都由这个类的实例表示
+ * 包含类型的 ID、名称、是否可引用等信息
+ * 以及编码和解码的方法
+ */
+export declare class AMFType {
+    /** 类型的数字标识符 */
+    id: number;
+    /** 类型的名称（用于调试和错误信息） */
+    name: string;
+    /**
+     * 是否可引用
+     * 某些复杂类型（如对象、数组）在 AMF 中可以被引用
+     * 以避免重复序列化相同的对象
+     */
+    referencable: boolean;
+    /**
+     * 编码函数
+     * 由具体的类型实现设置
+     * this 上下文指向 AMFEncoder 实例
+     */
+    encode: (this: any, value: any) => void;
+    /**
+     * 解码函数
+     * 由具体的类型实现设置
+     * this 上下文指向 AMFDecoder 实例
+     */
+    decode: (this: any) => any;
+    /**
+     * 创建一个新的 AMF 类型
+     *
+     * @param id - 类型的数字标识符
+     * @param name - 类型的名称
+     * @param referencable - 是否可引用，默认为 false
+     */
+    constructor(id: number, name: string, referencable?: boolean);
+}
+
+/**
+ * 可外部化对象基类
+ *
+ * 继承此类的对象可以完全控制自己的序列化和反序列化过程。
+ * 必须实现 write() 实例方法和 read() 静态方法。
+ *
+ * 可外部化对象需要通过 AMFDecoder.register() 注册，
+ * 以便解码器知道如何反序列化它们。
+ *
+ * @example
+ * ```typescript
+ * class CustomData extends Externalizable {
+ *     public data: Uint8Array;
+ *
+ *     constructor() {
+ *         super('com.example.CustomData');
+ *         this.data = new Uint8Array(0);
+ *     }
+ *
+ *     // 自定义序列化
+ *     write(encoder: AMFEncoder): void {
+ *         encoder.writeObject(this.data.length);
+ *         for (const byte of this.data) {
+ *             encoder.writeObject(byte);
+ *         }
+ *     }
+ *
+ *     // 自定义反序列化（静态方法）
+ *     static read(decoder: AMFDecoder): CustomData {
+ *         const instance = new CustomData();
+ *         const length = decoder.decode();
+ *         instance.data = new Uint8Array(length);
+ *         for (let i = 0; i < length; i++) {
+ *             instance.data[i] = decoder.decode();
+ *         }
+ *         return instance;
+ *     }
+ * }
+ * ```
+ */
+export declare class Externalizable extends Serializable {
+    /**
+     * 创建一个可外部化对象
+     *
+     * @param externalizableName - 对象的类名
+     */
+    constructor(externalizableName?: string);
+    /**
+     * 将对象写入编码器
+     *
+     * 子类必须覆盖此方法来实现自定义的序列化逻辑。
+     * 写入的数据必须能够被对应的 read() 静态方法正确读取。
+     *
+     * @param encoder - AMF 编码器实例
+     * @throws 如果子类没有实现此方法
+     */
+    write(encoder: AMFEncoder): void;
+    /**
+     * 从解码器读取并创建对象实例
+     *
+     * 子类必须定义一个同名的静态方法来实现自定义的反序列化逻辑。
+     * 此方法应该读取 write() 方法写入的数据并返回新的对象实例。
+     *
+     * 注意：这是一个静态方法，子类需要像这样定义：
+     * static read(decoder: AMFDecoder): YourClass { ... }
+     *
+     * @param decoder - AMF 解码器实例
+     * @returns 反序列化后的对象实例
+     * @throws 如果子类没有实现此方法
+     */
+    static read(decoder: AMFDecoder): Externalizable;
+}
+
+/**
+ * 可外部化对象静态读取接口
+ */
+declare interface ExternalizableReader {
+    read(decoder: AMFDecoder): any;
+}
+
+/**
+ * 强制类型值类
+ *
+ * 允许用户强制指定一个值应该被编码为特定的 AMF 类型
+ * 而不是由编码器自动推断类型
+ *
+ * @example
+ * ```typescript
+ * // 强制将数字编码为 AMF3 的 DOUBLE 类型而不是 INTEGER
+ * const forcedDouble = new ForcedTypeValue(42, AMF3.DOUBLE);
+ * encoder.writeObject(forcedDouble);
+ * ```
+ */
+export declare class ForcedTypeValue {
+    /** 实际要编码的值 */
+    value: any;
+    /** 强制使用的 AMF 类型 */
+    type: AMFType;
+    /**
+     * 创建一个强制类型值
+     *
+     * @param value - 实际要编码的值
+     * @param type - 强制使用的 AMF 类型
+     */
+    constructor(value: any, type: AMFType);
+}
+
+/**
+ * 二进制数据读取器类
+ *
+ * 提供从 Uint8Array 中读取各种二进制数据类型的方法
+ * 所有多字节数据都使用大端序（Big Endian）读取，这是 AMF 协议的要求
+ *
+ * @example
+ * ```typescript
+ * const data = new Uint8Array([0x00, 0x01, 0x02, 0x03]);
+ * const reader = new Reader(data);
+ * const byte = reader.readByte();        // 0x00
+ * const uint16 = reader.readUInt16BE();  // 0x0102
+ * ```
+ */
+declare class Reader {
+    /** 要读取的二进制数据 */
+    protected data: Uint8Array;
+    /** 用于读取多字节数据的 DataView */
+    protected view: DataView;
+    /** 当前读取位置 */
+    protected position: number;
+    /**
+     * 创建一个新的读取器
+     *
+     * @param data - 要读取的二进制数据
+     */
+    constructor(data: Uint8Array);
+    /**
+     * 获取当前读取位置
+     *
+     * @returns 当前位置（字节偏移量）
+     */
+    getPosition(): number;
+    /**
+     * 设置读取位置
+     *
+     * @param pos - 新的位置
+     */
+    setPosition(pos: number): void;
+    /**
+     * 获取剩余可读字节数
+     *
+     * @returns 剩余字节数
+     */
+    getBytesAvailable(): number;
+    /**
+     * 检查是否还有足够的字节可读
+     *
+     * @param length - 需要的字节数
+     * @throws 如果剩余字节不足
+     */
+    private checkAvailable;
+    /**
+     * 读取一个或多个字节
+     *
+     * @param length - 要读取的字节数，默认为 1
+     * @param alwaysReturnArray - 即使只读取一个字节也返回 Uint8Array
+     * @returns 如果 length 为 1 且 alwaysReturnArray 为 false，返回单个数字；否则返回 Uint8Array
+     */
+    readByte(length?: number, alwaysReturnArray?: boolean): number | Uint8Array;
+    /**
+     * 读取一个无符号 8 位整数
+     *
+     * @returns 0-255 范围内的整数
+     */
+    readUInt8(): number;
+    /**
+     * 读取一个有符号 8 位整数
+     *
+     * @returns -128 到 127 范围内的整数
+     */
+    readInt8(): number;
+    /**
+     * 读取一个大端序无符号 16 位整数
+     *
+     * @returns 0-65535 范围内的整数
+     */
+    readUInt16BE(): number;
+    /**
+     * 读取一个大端序有符号 16 位整数
+     *
+     * @returns -32768 到 32767 范围内的整数
+     */
+    readInt16BE(): number;
+    /**
+     * 读取一个大端序无符号 32 位整数
+     *
+     * @returns 0-4294967295 范围内的整数
+     */
+    readUInt32BE(): number;
+    /**
+     * 读取一个大端序有符号 32 位整数
+     *
+     * @returns -2147483648 到 2147483647 范围内的整数
+     */
+    readInt32BE(): number;
+    /**
+     * 读取一个大端序 64 位双精度浮点数
+     *
+     * @returns 双精度浮点数
+     */
+    readDoubleBE(): number;
+    /**
+     * 读取一个 AMF0 格式的字符串
+     *
+     * AMF0 字符串格式：2字节长度 + UTF-8 编码的字符串数据
+     *
+     * @returns 解码后的字符串
+     */
+    readString(): string;
+    /**
+     * 读取指定长度的 UTF-8 字符串
+     *
+     * @param length - 字符串的字节长度
+     * @returns 解码后的字符串
+     */
+    readUTF8String(length: number): string;
+    /**
+     * 读取 AMF3 的变长整数（Int29）
+     *
+     * AMF3 使用一种可变长度编码来表示 29 位有符号整数
+     * 每个字节的最高位表示是否还有更多字节：
+     * - 0xxxxxxx: 单字节，值 0-127
+     * - 1xxxxxxx 0xxxxxxx: 双字节
+     * - 1xxxxxxx 1xxxxxxx 0xxxxxxx: 三字节
+     * - 1xxxxxxx 1xxxxxxx 1xxxxxxx xxxxxxxx: 四字节（最后一个字节使用全部 8 位）
+     *
+     * @returns 29 位有符号整数，范围 -268435456 到 536870911
+     */
+    readInt29(): number;
+    /**
+     * 读取 AMF3 头部信息
+     *
+     * AMF3 中很多类型使用一个头部来区分是定义还是引用：
+     * - 最低位为 0: 这是一个引用，高位存储引用索引
+     * - 最低位为 1: 这是一个定义，高位存储数据长度或其他信息
+     *
+     * @returns AMF 头部信息对象
+     */
+    readAMFHeader(): AMFHeader;
+}
+
+/**
+ * 可序列化对象基类
+ *
+ * JavaScript 对象或类如果想要被序列化为"命名对象"（带有类名的对象），
+ * 应该继承这个类。
+ *
+ * 编码器会序列化对象的所有字段，除非：
+ * 1. 字段名以双下划线（__）开头
+ * 2. 对象定义了 getSerializableFields() 方法来指定要序列化的字段
+ *
+ * @example
+ * ```typescript
+ * class User extends Serializable {
+ *     public name: string;
+ *     public age: number;
+ *     private __password: string; // 不会被序列化
+ *
+ *     constructor() {
+ *         super('com.example.User');
+ *         this.name = '';
+ *         this.age = 0;
+ *         this.__password = '';
+ *     }
+ * }
+ * ```
+ */
+export declare class Serializable {
+    /**
+     * 对象的类名
+     * 如果为空或未定义，对象将被视为匿名对象
+     */
+    __class?: string;
+    /**
+     * 是否为动态对象
+     * - true 或 undefined: 动态编码（key-value 交替写入）
+     * - false: 静态编码（先写所有 key，再写所有 value）
+     */
+    __dynamic?: boolean;
+    /**
+     * 创建一个可序列化对象
+     *
+     * @param serializableName - 对象的类名（可选）
+     * @param dynamic - 是否为动态对象（可选，默认 true）
+     */
+    constructor(serializableName?: string, dynamic?: boolean);
+    /**
+     * 获取应该被序列化的字段列表
+     *
+     * 子类可以覆盖此方法来控制哪些字段会被序列化
+     * 注意：即使字段在此列表中，以双下划线开头的字段仍然会被忽略
+     *
+     * @returns 要序列化的字段名数组，如果返回 undefined 则序列化所有字段
+     *
+     * @example
+     * ```typescript
+     * getSerializableFields(): string[] {
+     *     return ['name', 'age', 'email'];
+     * }
+     * ```
+     */
+    getSerializableFields?(): string[];
+}
+
+/**
+ * 二进制数据写入器模块
+ *
+ * 本模块提供了向二进制缓冲区写入各种数据类型的功能
+ * 专为浏览器环境设计，使用 Uint8Array 和 DataView 替代 Node.js 的 Buffer
+ */
+/**
+ * 二进制数据写入器类
+ *
+ * 提供向动态增长的缓冲区写入各种二进制数据类型的方法
+ * 所有多字节数据都使用大端序（Big Endian）写入，这是 AMF 协议的要求
+ *
+ * @example
+ * ```typescript
+ * const writer = new Writer();
+ * writer.writeByte(0x01);
+ * writer.writeUInt16BE(0x0203);
+ * writer.writeDoubleBE(3.14159);
+ * const result = writer.getBuffer();
+ * ```
+ */
+declare class Writer {
+    /** 内部缓冲区数组，用于动态收集写入的数据 */
+    private chunks;
+    /** 当前已写入的总字节数 */
+    private totalLength;
+    /**
+     * 创建一个新的写入器
+     */
+    constructor();
+    /**
+     * 获取当前已写入的字节数
+     *
+     * @returns 已写入的总字节数
+     */
+    getLength(): number;
+    /**
+     * 获取写入的所有数据
+     *
+     * 将所有写入的数据块合并为一个 Uint8Array
+     *
+     * @returns 包含所有写入数据的 Uint8Array
+     */
+    getBuffer(): Uint8Array;
+    /**
+     * 清空写入器，重置到初始状态
+     */
+    clear(): void;
+    /**
+     * 写入数据到缓冲区
+     *
+     * 支持多种数据类型：
+     * - 数字（0-255）：作为单个字节写入
+     * - 数字数组：每个元素作为一个字节写入
+     * - Uint8Array：直接写入
+     * - 字符串：作为 UTF-8 编码写入
+     *
+     * @param value - 要写入的值
+     * @throws 如果值的类型不支持
+     */
+    write(value: number | number[] | Uint8Array | string): void;
+    /**
+     * 写入单个字节
+     *
+     * @param value - 0-255 范围内的整数
+     */
+    writeByte(value: number): void;
+    /**
+     * 写入字节数组
+     *
+     * @param bytes - 字节数组或 Uint8Array
+     */
+    writeBytes(bytes: number[] | Uint8Array): void;
+    /**
+     * 写入一个大端序无符号 16 位整数
+     *
+     * @param value - 0-65535 范围内的整数
+     */
+    writeUInt16BE(value: number): void;
+    /**
+     * 写入一个大端序有符号 16 位整数
+     *
+     * @param value - -32768 到 32767 范围内的整数
+     */
+    writeInt16BE(value: number): void;
+    /**
+     * 写入一个大端序无符号 32 位整数
+     *
+     * @param value - 0-4294967295 范围内的整数
+     */
+    writeUInt32BE(value: number): void;
+    /**
+     * 写入一个大端序有符号 32 位整数
+     *
+     * @param value - -2147483648 到 2147483647 范围内的整数
+     */
+    writeInt32BE(value: number): void;
+    /**
+     * 写入一个大端序 64 位双精度浮点数
+     *
+     * @param value - 双精度浮点数
+     */
+    writeDoubleBE(value: number): void;
+    /**
+     * 写入一个 AMF0 格式的字符串
+     *
+     * AMF0 字符串格式：2字节长度（大端序）+ UTF-8 编码的字符串数据
+     *
+     * @param value - 要写入的字符串
+     */
+    writeString(value: string): void;
+    /**
+     * 写入 AMF3 的变长整数（Int29）
+     *
+     * AMF3 使用一种可变长度编码来表示 29 位有符号整数
+     * 每个字节的最高位表示是否还有更多字节：
+     * - 值 0-127: 单字节 (0xxxxxxx)
+     * - 值 128-16383: 双字节 (1xxxxxxx 0xxxxxxx)
+     * - 值 16384-2097151: 三字节 (1xxxxxxx 1xxxxxxx 0xxxxxxx)
+     * - 值 2097152-536870911: 四字节 (1xxxxxxx 1xxxxxxx 1xxxxxxx xxxxxxxx)
+     *
+     * @param value - 29 位有符号整数，范围 -268435456 到 536870911
+     * @throws 如果值超出范围
+     */
+    writeInt29(value: number): void;
+}
+
+export { }