type PrimaryType = "void" | "bool" | "int8" | "int16" | "int32" | "int64" | "uint8" | "uint16" | "uint32" | "uint64" | "float" | "double" | "pointer" | "string" | "u16string";

    
declare namespace FFI {

    // 不可变的C语言指针类型, 相当于C语言的void*
    interface FfiPointer {
        // 读取内存. 
        Read(type: PrimaryType, offset: NumberLike): Value;
        // 写入内存
        Write(type: PrimaryType, offset: NumberLike, value: Value): void;
        // 指针转数字
        ToBigInt(): bigint | number;
        // 指针加法操作
        AddOffset(offset: NumberLike): FfiPointer;
        // C语言字符串指针(const char*)转js字符串
        DerefString(): string;
        // C语言宽字符串指针(const char16_t*)转js字符串
        DerefU16String(): string;
    }

    // 数值转指针
    function BigIntToPointer(value: bigint | number): FfiPointer;
}
declare namespace ffi {
    // 这些类型可以作为函数参数, 能自动转为指针类型
    type FfiPointerLike = FfiPointer | ArrayBuffer | FfiClosure | null;
    // 创建指针类型. 
    function Pointer(inner: TypeDecl): PointerType
    // 指针值. 可以为js的null
    type PointerValue = FFI.FfiPointer & {
        type: PointerType,
        // 相当于C语言指针的加法运算. index默认为0
        ref(index?: number): PointerValue,
        // 相当于C语言的指针读取, 或数组元素读取. index默认为0
        read(index?: number): any,
        // 相当于C语言的指针写入, 或数组元素写入. index默认为0
        write(value: any, index?: number): void,
    } | null;
    
    // 指针类型
    interface PointerType extends Type<PointerValue> {
        kind: 'pointer',
        pointeeType: Type<any>,
        create(pointer: FFI.FfiPointer | null): PointerValue,
        // 创建null指针值
        null(): PointerValue,
    }
}

    // 创建函数类型. 
    function Function(typeinfo: FunctionTypeDecl): FunctionType;
    // 函数类型的实例, 是一个带有额外属性的js函数, 或者为null
    type FunctionValue = ((...args: FFI.Value[]) => FFI.Value | undefined) & {
        type: FunctionType,
    } & (
            { isJSFunction: false, inner: FFI.FfiFunction }
            | { isJSFunction: true, inner: FFI.FfiClosure }
        ) | null;
    
    // 函数类型
    interface FunctionType extends Type<FunctionValue> {
        kind: 'function',
        // 参数类型
        parametersType: Type<any>[],
        // 返回值类型
        returnType: Type<any>,
        // 调用约定
        abi: FFI.Abi,
        // js函数转闭包对象
        createJsFunction(value: (...args: FFI.Value[]) => FFI.Value | undefined): FunctionValue,
        // C函数指针转js函数
        wrapCFunction(value: FFI.FfiPointer): FunctionValue,
    }

    // 创建结构体类型. 返回值本身是个类构造函数, 可以用new创建值
    function Struct(fields: FieldDecl[]): StructType  & (new (value?: Record<string, any>) => StructValue);

    // 结构体值
    type StructValue = ArrayBuffer & {
        type: StructType,
        // 转为js对象
        toObject(): object,
    }
    
    // 结构体类型
    interface StructType extends Type<StructValue> {
        kind: 'struct',
        // 字段列表
        fields: RawFieldDecl[],
        // 按照对象的键值对创建结构体值
        create(value?: object): StructValue,
    }

    // 创建定长数组类型. 返回值本身是个类构造函数, 可以用new创建值
    function Array(inner: TypeDecl, length: number): ArrayType & (new (value?: any[]) => ArrayValue); 
    // 定长数组值
    type ArrayValue = ArrayBuffer & {
        type: ArrayType,
        // 获取元素指针. index默认为0
        ref(index?: number): PointerValue,
        // 解码出元素的js值
        get(index: number): any,
        // 编码js值到元素
        set(index: number, value: any): void,
    }
    
    // 定长数组类型
    interface ArrayType extends Type<ArrayValue> {
        kind: 'array',
        // 元素类型
        elementType: Type<any>,
        // 数组长度
        arrayLength: number,
        // 从js数组
        create(value: FFI.Value[]): ArrayValue,
    }

    // 创建缓冲区类型. 返回值本身是个类构造函数, 可以用new创建值
    function Buffer(inner: TypeDecl): BufferType & (new (value?: any) => BufferValue);

    // 缓冲区类型, 是一个ArrayBuffer, 用于持有一个C内存结构. 可以作为C api通过指针传出数据的缓冲区
    type BufferValue = ArrayBuffer & {
        type: BufferType,
        // 转指针
        ref(): PointerValue,
        // 解码出js值
        read(): any,
        // 编码js值
        write(value: any): void,
    };
    
    // 缓冲区类型
    interface BufferType extends Type<BufferValue> {
        kind: 'buffer',
        innerType: Type<any>,
        create(value: any): BufferValue,
    }

    // 创建联合体类型. 返回值本身是个类构造函数, 可以用new创建值
    function Union(fields: FieldDecl[]): UnionType & (new () => UnionValue);
    
    // 联合体值
    type UnionValue = ArrayBuffer & {
        type: UnionType
    }
    
    // 联合体类型
    interface UnionType extends Type<UnionValue> {
        kind: 'union',
        // 变体列表
        fields: RawFieldDecl[],
    }

    type Abi = "" // 默认abi
        | "stdcall" | "thiscall" | "fastcall" | "cdecl" | "pascal" | "sysv" // x86和x64的abi，包括Intel和AMD，兆芯，海光等CPU
        | "win64" /*非windows平台*/ | "gnuw64" | "unix64" // x64架构
        | "win64" | "sysv" // aarch64架构，包括，飞腾，鲲鹏，麒麟，苹果M1/M2等CPU
        | "n64" | "n64_soft_float" // mips64el架构，龙芯3A4000及以下
        | "lp64s" | "lp64f" | "lp64d";  // loongarch64架构，龙芯3A5000及以上

declare namespace ffi {
    // 加载动态库, 以及动态库函数
    function LoadLibrary(name: string, functions: Record<string, LibraryFunctionDecl>): FFI.FFILibrary & Record<string, (...args: any[]) => any>;
    
    interface FunctionTypeDecl {
        parameters?: TypeDecl[],
        returnType?: TypeDecl,
        abi?: FFI.Abi
    }

    interface LibraryFunctionDecl extends FunctionTypeDecl {
        // 函数在动态库中的符号名, 如果与函数名相同, 则可以省略
        symbol?: string,
    }
}
declare namespace FFI {
    // 加载动态库. name可以是绝对路径或名字
    function LoadLibrary(name: string): FFILibrary;

    // 动态库对象
    interface FFILibrary {
        // 加载动态库函数
        LoadFunction(name: string, symbol: string, abi: Abi, returnType: PrimaryType, argumentsType: PrimaryType[]): FfiFunction;
    }
}

// 在C++中实现的api, 其类型转换受到C++层的限制. 比如bigint类型的返回值实际可能被转为number
declare namespace FFI {
    type Abi = "" // 默认abi
        | "stdcall" | "thiscall" | "fastcall" | "cdecl" | "pascal" | "sysv" // x86和x64的abi，包括Intel和AMD，兆芯，海光等CPU
        | "win64" /*非windows平台*/ | "gnuw64" | "unix64" // x64架构
        | "win64" | "sysv" // aarch64架构，包括，飞腾，鲲鹏，麒麟，苹果M1/M2等CPU
        | "n64" | "n64_soft_float" // mips64el架构，龙芯3A4000及以下
        | "lp64s" | "lp64f" | "lp64d";  // loongarch64架构，龙芯3A5000及以上
    type PrimaryType = "void" | "bool" | "int8" | "int16" | "int32" | "int64" | "uint8" | "uint16" | "uint32" | "uint64" | "float" | "double" | "pointer" | "string" | "u16string";
    // 大多数jsapi可以自动转为整数的类型
    type NumberLike = number | bigint | string;

    // 不可变的C语言指针类型, 相当于C语言的void*
    interface FfiPointer {
        // 读取内存. 
        Read(type: PrimaryType, offset: NumberLike): Value;
        // 写入内存
        Write(type: PrimaryType, offset: NumberLike, value: Value): void;
        // 指针转数字
        ToBigInt(): bigint | number;
        // 指针加法操作
        AddOffset(offset: NumberLike): FfiPointer;
        // C语言字符串指针(const char*)转js字符串
        DerefString(): string;
        // C语言宽字符串指针(const char16_t*)转js字符串
        DerefU16String(): string;
    }

    // 闭包类型, 是可调用的函数对象, 内部包含运行期生成的机器码
    interface FfiClosure {
        // 用于设置回调函数. 闭包的机器码被调用时会调用回调函数。
        // 如果手动用CreateCallback创建闭包对象, 则必须设置此回调函数。否则调用闭包时只会返回未定义值给C函数
        OnCall?: (...args: Value[]) => Value | undefined;
        // 获取内部的机器码的指针
        ToPointer(): FfiPointer;
    }

    // 函数对象, 用于调用函数
    interface FfiFunction {
        // 调用函数. 要求参数数量正确, 参数类型正确
        Call(...args: Value[]): Value | undefined;
        // 获取函数指针
        ToPointer(): FfiPointer;
    }

    // 动态库对象
    interface FFILibrary {
        // 加载动态库函数
        LoadFunction(name: string, symbol: string, abi: Abi, returnType: PrimaryType, argumentsType: PrimaryType[]): FfiFunction;
    }

    type FfiPointerLike = FfiPointer | ArrayBuffer | FfiClosure | null;
    type Value = number | bigint | string | boolean | FfiPointerLike;
    
    // 加载动态库. name可以是绝对路径或名字
    function LoadLibrary(name: string): FFILibrary;
    // 创建闭包对象
    function CreateCallback(abi: Abi, returnType: PrimaryType, argumentsType: PrimaryType[]): FfiClosure;
    // 函数指针转为函数
    function CreateFunction(pointer: FfiPointer, abi: Abi, returnType: PrimaryType, argumentsType: PrimaryType[]): FfiFunction;

    // 获取js缓冲区中特定未知的指针
    function DerefPointer(array: ArrayBuffer, offset?: number): FfiPointer;
    // 获取js缓冲区开头的指针
    function RefPointer(pointer: ArrayBuffer | FfiPointer): FfiPointer;
    // 数值转指针
    function BigIntToPointer(value: bigint | number): FfiPointer;
    // 分配内存. size会被转为无符号整数
    function Malloc(size: number): FfiPointer;
    // 释放分配的内存
    function Free(pointer: FfiPointer): void;
    
    // 复制内存
    // dest: 复制目标
    // destOffset: 复制目标上的偏移量
    // destSize: 复制目标上的复制区域大小
    // src: 复制源
    // srcOffset: 复制源上的偏移量
    // srcSize: 复制源上的复制区域大小
    function Memcpy(dest: FfiPointer | ArrayBuffer, destOffset: NumberLike, destSize: number, src: FfiPointer | ArrayBuffer, srcOffset: number, secSize: number): void;

    // 当前系统的指针大小(byte). 值为4或8，对应32位或64位WPS
    const PointerSize: number;
}

// ffi模块是在js中实现的, 是对FFI模块的一层封装. 其使用方式更复合js习惯
declare namespace ffi {
    // 转换函数调用的参数
    type ParamsEncoder = (value: any) => any;
    
    // 各种api接受的类型值的类型
    type TypeDecl = Type<any> | FFI.PrimaryType
    
    // 把值编码到Uint8Array中
    type EncoderFn<V> = (buffer: Uint8Array<ArrayBuffer>, offset: number, value: V) => void;
    // 从Uint8Array解码出值
    type DecoderFn<V> = (buffer: Uint8Array<ArrayBuffer>, offset: number) => V;
    // 转换函数调用的参数, 和闭包的返回值
    type ParamsEncodersFn<V> = (value: V) => any;
    // 转换函数调用的返回值, 和闭包的参数
    type ReturnDecodersFn<V> = (value: any) => V;
    // 从指针读取值
    type Reader<V> = (pointer: FFI.FfiPointer, offset: number) => V;
    // 向指针写入值
    type Writer<V> = (pointer: FFI.FfiPointer, offset: number, value: V) => void;
    
    // 类型的定义
    interface Type<V> {
        primaryType: FFI.PrimaryType,
        // 类型大小 以byte为单位
        size: number,
        // 类型的对齐值, 必须是2的n次方
        align: number,
        // Uint8Array编码器
        encoder: EncoderFn<V>,
        // Uint8Array解码器
        decoder: DecoderFn<V>,
        // 指针读取器
        reader: Reader<V>,
        // 指针写入器
        writer: Writer<V>,
        // 参数转换器. 如果为undefined, 则不会转换
        paramEncoder?: ParamsEncodersFn<V>,
        // 返回值转换器. 如果为undefined, 则不会转换
        returnValueDecoder?: ReturnDecodersFn<V>,
    }
    
    // 函数类型的实例, 是一个带有额外属性的js函数, 或者为null
    type FunctionValue = ((...args: FFI.Value[]) => FFI.Value | undefined) & {
        type: FunctionType,
    } & (
            { isJSFunction: false, inner: FFI.FfiFunction }
            | { isJSFunction: true, inner: FFI.FfiClosure }
        ) | null;
    
    // 函数类型
    interface FunctionType extends Type<FunctionValue> {
        kind: 'function',
        // 参数类型
        parametersType: Type<any>[],
        // 返回值类型
        returnType: Type<any>,
        // 调用约定
        abi: FFI.Abi,
        // js函数转闭包对象
        createJsFunction(value: (...args: FFI.Value[]) => FFI.Value | undefined): FunctionValue,
        // C函数指针转js函数
        wrapCFunction(value: FFI.FfiPointer): FunctionValue,
    }
    
    // 缓冲区类型, 是一个ArrayBuffer, 用于持有一个C内存结构. 可以作为C api通过指针传出数据的缓冲区
    type BufferValue = ArrayBuffer & {
        type: BufferType,
        // 转指针
        ref(): PointerValue,
        // 解码出js值
        read(): any,
        // 编码js值
        write(value: any): void,
    };
    
    // 缓冲区类型
    interface BufferType extends Type<BufferValue> {
        kind: 'buffer',
        innerType: Type<any>,
        create(value: any): BufferValue,
    }
    
    // 结构体值
    type StructValue = ArrayBuffer & {
        type: StructType,
        // 转为js对象
        toObject(): object,
    }
    
    // 结构体类型
    interface StructType extends Type<StructValue> {
        kind: 'struct',
        // 字段列表
        fields: RawFieldDecl[],
        // 按照对象的键值对创建结构体值
        create(value?: object): StructValue,
    }
    
    // 联合体值
    type UnionValue = ArrayBuffer & {
        type: UnionType
    }
    
    // 联合体类型
    interface UnionType extends Type<UnionValue> {
        kind: 'union',
        // 变体列表
        fields: RawFieldDecl[],
    }
    
    // 指针值. 可以为js的null
    type PointerValue = FFI.FfiPointer & {
        type: PointerType,
        // 相当于C语言指针的加法运算. index默认为0
        ref(index?: number): PointerValue,
        // 相当于C语言的指针读取, 或数组元素读取. index默认为0
        read(index?: number): any,
        // 相当于C语言的指针写入, 或数组元素写入. index默认为0
        write(value: any, index?: number): void,
    } | null;
    
    // 指针类型
    interface PointerType extends Type<PointerValue> {
        kind: 'pointer',
        pointeeType: Type<any>,
        create(pointer: FFI.FfiPointer | null): PointerValue,
        // 创建null指针值
        null(): PointerValue,
    }
    
    // 定长数组值
    type ArrayValue = ArrayBuffer & {
        type: ArrayType,
        // 获取元素指针. index默认为0
        ref(index?: number): PointerValue,
        // 解码出元素的js值
        get(index: number): any,
        // 编码js值到元素
        set(index: number, value: any): void,
    }
    
    // 定长数组类型
    interface ArrayType extends Type<ArrayValue> {
        kind: 'array',
        // 元素类型
        elementType: Type<any>,
        // 数组长度
        arrayLength: number,
        // 从js数组
        create(value: FFI.Value[]): ArrayValue,
    }
    
    type BottomType = (Type<any> & { kind: undefined }) | FunctionType | StructType | UnionType | PointerType | ArrayType | BufferType;
    
    interface FieldDecl {
        name: string,
        type: TypeDecl,
    }
    
    interface ResolvedField {
        name: string,
        type: Type<any>,
    }
    
    interface RawFieldDecl {
        name: string,
        type: Type<any>,
        offset: number,
    }
    
    interface FunctionTypeDecl {
        parameters?: TypeDecl[],
        returnType?: TypeDecl,
        abi?: FFI.Abi
    }

    interface LibraryFunctionDecl extends FunctionTypeDecl {
        // 函数在动态库中的符号名, 如果与函数名相同, 则可以省略
        symbol?: string,
    }

    // 各种内置类型
    let types: {
        void: Type<void>,
        bool: Type<boolean>,
        int8: Type<number>,
        int16: Type<number>,
        int32: Type<number>,
        int64: Type<bigint>,
        uint8: Type<number>,
        uint16: Type<number>,
        uint32: Type<number>,    
        uint64: Type<bigint>,
        float: Type<number>,
        double: Type<number>,
        string: Type<string>,
        "char*": Type<string>,
        u16string: Type<string>,
        pointer: Type<FFI.FfiPointer | null>,
        "void*": Type<FFI.FfiPointer | null>,
        size_t: Type<number> | Type<bigint>,
    };
    // 加载动态库, 以及动态库函数
    function LoadLibrary(name: string, functions: Record<string, LibraryFunctionDecl>): FFI.FFILibrary & Record<string, (...args: any[]) => any>;
    // 解析类型声明
    function resolveType(type: TypeDecl): Type<any>;
    // 指针大小
    let pointerSize: number;
    // 创建结构体类型. 返回值本身是个类构造函数, 可以用new创建值
    function Struct(fields: FieldDecl[]): StructType  & (new (value?: Record<string, any>) => StructValue);
    // 创建联合体类型. 返回值本身是个类构造函数, 可以用new创建值
    function Union(fields: FieldDecl[]): UnionType & (new () => UnionValue);
    // 创建函数类型. 
    function Function(typeinfo: FunctionTypeDecl): FunctionType;
    // 创建定长数组类型. 返回值本身是个类构造函数, 可以用new创建值
    function Array(inner: TypeDecl, length: number): ArrayType & (new (value?: any[]) => ArrayValue); 
    // 创建指针类型. 
    function Pointer(inner: TypeDecl): PointerType
    // 创建缓冲区类型. 返回值本身是个类构造函数, 可以用new创建值
    function Buffer(inner: TypeDecl): BufferType & (new (value?: any) => BufferValue);
}