jsilnet 0.1.0 → 0.2.0

package/src/types/metadata/portable-pdb.d.ts

@@ -0,0 +1,296 @@
+export function validatePortablePdbAssemblyReferences(pdb: any, assemblyRowCounts: any): void;
+export function updateEmbeddedPortablePdbRowCounts(pdb: any, assemblyRowCounts: any): Uint8Array<ArrayBuffer>;
+export function validatePortablePdbCodeViewIdentity(pdb: any, codeView: any, timeDateStamp: any): void;
+export function decodePortablePdbCustomDebugInformation(row: any, heaps: any, documentCount?: number, methodCount?: number): {
+    kind: string;
+    embeddedSource: any;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    sourceLink: any;
+    embeddedSource?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    defaultNamespace: string;
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    dynamicLocalVariables: any;
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    compilationOptions: {
+        name: string;
+        value: string;
+    }[];
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    compilationMetadataReferences: {
+        fileName: string;
+        aliases: string;
+        flags: any;
+        timeStamp: number;
+        fileSize: number;
+        mvid: any;
+    }[];
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    typeDefinitionDocuments: any[];
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    asyncMethodSteppingInformation: {
+        catchHandlerOffset: number;
+        steps: {
+            yieldOffset: number;
+            resumeOffset: number;
+            methodRid: any;
+        }[];
+    };
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    stateMachineHoistedLocalScopes: {
+        startOffset: number;
+        length: number;
+    }[];
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    editAndContinueStateMachineStateMap: {
+        stateNumber: number;
+        syntaxOffset: any;
+    }[];
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    editAndContinueLocalSlotMap: {
+        syntaxOffsetBaseline: number;
+        slots: {
+            kind: number;
+            syntaxOffset: any;
+            ordinal: any;
+        }[];
+    };
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+} | {
+    kind: string;
+    editAndContinueLambdaAndClosureMap: {
+        methodOrdinal: any;
+        syntaxOffsetBaseline: any;
+        closures: any[];
+        lambdas: {
+            syntaxOffset: any;
+            closureOrdinal: any;
+        }[];
+    };
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+} | {
+    kind: string;
+    embeddedSource?: undefined;
+    sourceLink?: undefined;
+    defaultNamespace?: undefined;
+    dynamicLocalVariables?: undefined;
+    compilationOptions?: undefined;
+    compilationMetadataReferences?: undefined;
+    typeDefinitionDocuments?: undefined;
+    asyncMethodSteppingInformation?: undefined;
+    stateMachineHoistedLocalScopes?: undefined;
+    editAndContinueStateMachineStateMap?: undefined;
+    editAndContinueLocalSlotMap?: undefined;
+    editAndContinueLambdaAndClosureMap?: undefined;
+};
+export function decodePortablePdbDocumentName(blob: any, heaps: any): string;
+export function encodePortablePdbDocumentName(separator: any, partBlobIndices: any): Uint8Array<ArrayBuffer>;
+export function appendPortablePdbDocumentName(blobHeap: any, name: any, separator: any): {
+    heap: Uint8Array<any>;
+    nameBlobIndex: any;
+    nameBlob: Uint8Array<ArrayBuffer>;
+};
+export function decodePortablePdbSequencePoints(blob: any, { documentRid, documentCount, localSignatureCount }: {
+    documentRid: any;
+    documentCount: any;
+    localSignatureCount: any;
+}): {
+    localSignatureRid: any;
+    points: {
+        offset: any;
+        documentRid: any;
+        hidden: boolean;
+        startLine: number;
+        startColumn: number;
+        endLine: number;
+        endColumn: number;
+    }[];
+};
+export function encodePortablePdbSequencePoints(sequencePoints: any, { documentRid, documentCount, localSignatureCount }?: {}): Uint8Array<ArrayBuffer>;
+export function parsePortablePdbTables(tables: any, heaps: any, typeSystemCounts: any): {
+    documents: any[];
+    methodDebugInformation: any;
+    stateMachineMethods: any;
+    customDebugInformation: any;
+};
+export function serializeEmbeddedPortablePdb(pdb: any): Uint8Array<ArrayBuffer>;
+export function refreshEmbeddedPortablePdbId(pdb: any): {
+    bytes: Uint8Array<ArrayBuffer>;
+    id: any;
+    hashes: Map<any, any>;
+};
+export function replaceEmbeddedPortablePdbDocumentName(pdb: any, documentRid: any, name: any, separator: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbDocumentMetadata(pdb: any, documentRid: any, options: any): Uint8Array<ArrayBuffer>;
+export function addEmbeddedPortablePdbDocument(pdb: any, name: any, options: any): Uint8Array<ArrayBuffer>;
+export function insertEmbeddedPortablePdbDocument(pdb: any, options?: {}): Uint8Array<ArrayBuffer>;
+export function addEmbeddedPortablePdbTypeDefinitionDocuments(pdb: any, typeRid: any, documentRids: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbTypeDefinitionDocuments(pdb: any, typeRid: any, documentRids: any): Uint8Array<ArrayBuffer>;
+export function removeEmbeddedPortablePdbDocument(pdb: any, documentRid: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbSequencePoints(pdb: any, methodRid: any, sequencePoints: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbMethodDocument(pdb: any, methodRid: any, documentRid: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbCustomDebugInformation(pdb: any, customDebugInformationRid: any, value: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbLocalScope(pdb: any, localScopeRid: any, options: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbLocalVariable(pdb: any, localVariableRid: any, options: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbLocalConstant(pdb: any, localConstantRid: any, options: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbImportScope(pdb: any, importScopeRid: any, options: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbMethodOffsets(pdb: any, methodRid: any, { sequencePoints, localSignatureRid, scopes, stateMachineHoistedLocalScopes, asyncMethodSteppingInformation }?: {
+    sequencePoints?: any;
+    localSignatureRid?: number;
+    scopes?: any[];
+    stateMachineHoistedLocalScopes?: any[];
+    asyncMethodSteppingInformation?: any[];
+}): Uint8Array<ArrayBuffer>;
+export function insertEmbeddedPortablePdbMethod(pdb: any, methodRid: any, oldCounts: any, newCounts: any): Uint8Array<ArrayBuffer>;
+export function remapEmbeddedPortablePdbLocalSignatures(pdb: any, signatureRid: any, oldCounts: any, newCounts: any, operation: any): Uint8Array<ArrayBuffer>;
+export function remapEmbeddedPortablePdbTypeDefinitions(pdb: any, typeRid: any, oldCounts: any, newCounts: any, operation: any): Uint8Array<ArrayBuffer>;
+export function removeEmbeddedPortablePdbMethod(pdb: any, methodRid: any, oldCounts: any, newCounts: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbSource(pdb: any, documentRid: any, source: any, { compress }?: {
+    compress?: boolean;
+}): Uint8Array<ArrayBuffer>;
+export function addEmbeddedPortablePdbSource(pdb: any, documentRid: any, source: any, { compress }?: {
+    compress?: boolean;
+}): Uint8Array<ArrayBuffer>;
+export function removeEmbeddedPortablePdbSource(pdb: any, documentRid: any): Uint8Array<ArrayBuffer>;
+export function removeEmbeddedPortablePdbCustomDebugInformation(pdb: any, recordRid: any): Uint8Array<ArrayBuffer>;
+export function addEmbeddedPortablePdbSourceLink(pdb: any, sourceLink: any): Uint8Array<ArrayBuffer>;
+export function replaceEmbeddedPortablePdbSourceLink(pdb: any, sourceLink: any): Uint8Array<ArrayBuffer>;
+export function removeEmbeddedPortablePdbSourceLink(pdb: any): Uint8Array<ArrayBuffer>;

package/src/types/metadata/resources.d.ts

@@ -0,0 +1 @@
+export function parseManifestResources(bytes: any, directory: any, rows: any, heaps: any, rvaToOffset: any): any;

package/src/types/metadata/root-writer.d.ts

@@ -0,0 +1 @@
+export function serializeMetadataRoot(root: any, streams: any): Uint8Array<ArrayBuffer>;

package/src/types/metadata/signatures.d.ts

@@ -0,0 +1,5 @@
+export function parseSignature(input: any, { counts }?: {}): any;
+export function parseTypeSignature(input: any, { counts }?: {}): any;
+export function encodeSignature(signature: any): Uint8Array<ArrayBuffer>;
+export function encodeTypeSignature(signature: any): Uint8Array<ArrayBuffer>;
+export function remapTypeReferences(signature: any, remapRid: any, tableId?: number): any;

package/src/types/metadata/streams.d.ts

@@ -0,0 +1,26 @@
+export function parseMetadataRoot(input: any, offset: any, size: any): {
+    offset: any;
+    size: any;
+    majorVersion: number;
+    minorVersion: number;
+    version: string;
+    versionLength: number;
+    versionBytes: Uint8Array<any>;
+    flags: number;
+    streams: Map<any, any>;
+};
+export class MetadataHeaps {
+    constructor(streams: any);
+    strings: any;
+    userStrings: any;
+    guids: any;
+    blobs: any;
+    userStringDataEnd: any;
+    blobEntryOffsets: Set<number>;
+    userStringEntryOffsets: Set<number>;
+    getString(index: any): string;
+    getBlob(index: any): Uint8Array<ArrayBuffer>;
+    getGuid(index: any): any;
+    getUserString(tokenOrOffset: any): string;
+    #private;
+}

package/src/types/metadata/strong-name.d.ts

@@ -0,0 +1,11 @@
+export function getStrongNameHashName(algorithm: any): string;
+export function importStrongNamePrivateKey(input: any): any;
+export function encodeStrongNamePublicKey(keyInput: any, hashAlgorithm: any): any;
+export function decodeStrongNamePublicKey(bytes: any): {
+    publicKey: any;
+    hashAlgorithm: number;
+    signatureSize: number;
+};
+export function assertStrongNamePEProfile(pe: any): 96 | 112;
+export function signStrongNameImage(bytes: any, pe: any, cli: any, privateKey: any, hashAlgorithm: any): Uint8Array<ArrayBuffer>;
+export function verifyStrongNameImage(bytes: any, pe: any, cli: any, publicKeyBytes: any, hashAlgorithm: any): any;

package/src/types/metadata/tables.d.ts

@@ -0,0 +1,25 @@
+export function decodeCodedIndex(value: any, kind: any): {
+    table: any;
+    tableName: string;
+    rid: number;
+};
+export function encodeCodedIndex(table: any, rid: any, kind: any): any;
+export function codedIndexWidth(kind: any, counts: any): 2 | 4;
+export function tableIndexWidth(rowCount: any): 2 | 4;
+export function parseTablesStream(stream: any, externalCounts?: any): {
+    majorVersion: number;
+    minorVersion: number;
+    reserved: number;
+    reservedByte: number;
+    heapSizes: number;
+    valid: bigint;
+    sorted: bigint;
+    counts: any[];
+    rows: Map<any, any>;
+    tableDataOffset: number;
+    row(idOrName: any, rid: any): any;
+    get(idOrName: any): any;
+};
+export function metadataTableId(nameOrId: any): any;
+export const metadataTableNames: string[];
+export const metadataTableSchemas: (string | number)[][][];

package/src/types/metadata/writer.d.ts

@@ -0,0 +1,16 @@
+export function serializeTablesStream(tables: any, heapStreams: any): Uint8Array<ArrayBuffer>;
+export function appendCompressedUInt(value: any): Uint8Array<ArrayBuffer>;
+export function appendCompressedInt(value: any): Uint8Array<ArrayBuffer>;
+export function appendStringHeap(heap: any, value: any): {
+    heap: Uint8Array<any>;
+    index: any;
+};
+export function appendBlobHeap(heap: any, value: any): {
+    heap: Uint8Array<any>;
+    index: any;
+};
+export function appendUserStringHeap(heap: any, value: any): {
+    heap: Uint8Array<any>;
+    index: any;
+};
+export function tableName(id: any): string;

package/src/types/pe/headers.d.ts

@@ -0,0 +1,160 @@
+export function parseEmbeddedPortablePdbData(bytes: any, offset: any, size: any): {
+    id: Uint8Array<ArrayBuffer>;
+    entryPointToken: number;
+    referencedTypeSystemTables: bigint;
+    rowCounts: Map<any, any>;
+    documents: any[];
+    methodDebugInformation: any;
+    stateMachineMethods: any;
+    customDebugInformation: any;
+    uncompressedSize: number;
+    bytes: Uint8Array<ArrayBuffer>;
+    metadataRoot: {
+        offset: any;
+        size: any;
+        majorVersion: number;
+        minorVersion: number;
+        version: string;
+        versionLength: number;
+        versionBytes: Uint8Array<any>;
+        flags: number;
+        streams: Map<any, any>;
+    };
+    tables: {
+        majorVersion: number;
+        minorVersion: number;
+        reserved: number;
+        reservedByte: number;
+        heapSizes: number;
+        valid: bigint;
+        sorted: bigint;
+        counts: any[];
+        rows: Map<any, any>;
+        tableDataOffset: number;
+        row(idOrName: any, rid: any): any;
+        get(idOrName: any): any;
+    };
+    heaps: MetadataHeaps;
+};
+export function parsePE(input: any): {
+    bytes: Uint8Array<any>;
+    peOffset: number;
+    machine: number;
+    sectionCount: number;
+    symbolTablePointer: number;
+    symbolCount: number;
+    characteristics: number;
+    optionalHeaderOffset: number;
+    optionalHeaderSize: number;
+    optionalHeaderMagic: number;
+    sectionOffset: number;
+    sizeOfCode: number;
+    sizeOfInitializedData: number;
+    sectionAlignment: number;
+    fileAlignment: number;
+    sizeOfImage: number;
+    sizeOfHeaders: number;
+    checksumOffset: number;
+    directories: {
+        rva: number;
+        size: number;
+    }[];
+    debugDirectoryEntries: {
+        characteristics: number;
+        timeDateStamp: number;
+        majorVersion: number;
+        minorVersion: number;
+        type: number;
+        sizeOfData: number;
+        addressOfRawData: number;
+        pointerToRawData: number;
+        codeView: {
+            format: string;
+            signature: string;
+        } | {
+            path: string;
+            pathOffset: number;
+            pathByteLength: any;
+            guid: string;
+            age: number;
+            format: string;
+            signature?: undefined;
+        } | {
+            path: string;
+            pathOffset: number;
+            pathByteLength: any;
+            offset: number;
+            timeDateStamp: number;
+            age: number;
+            format: string;
+            signature?: undefined;
+        };
+        embeddedPortablePdb: {
+            id: Uint8Array<ArrayBuffer>;
+            entryPointToken: number;
+            referencedTypeSystemTables: bigint;
+            rowCounts: Map<any, any>;
+            documents: any[];
+            methodDebugInformation: any;
+            stateMachineMethods: any;
+            customDebugInformation: any;
+            uncompressedSize: number;
+            bytes: Uint8Array<ArrayBuffer>;
+            metadataRoot: {
+                offset: any;
+                size: any;
+                majorVersion: number;
+                minorVersion: number;
+                version: string;
+                versionLength: number;
+                versionBytes: Uint8Array<any>;
+                flags: number;
+                streams: Map<any, any>;
+            };
+            tables: {
+                majorVersion: number;
+                minorVersion: number;
+                reserved: number;
+                reservedByte: number;
+                heapSizes: number;
+                valid: bigint;
+                sorted: bigint;
+                counts: any[];
+                rows: Map<any, any>;
+                tableDataOffset: number;
+                row(idOrName: any, rid: any): any;
+                get(idOrName: any): any;
+            };
+            heaps: MetadataHeaps;
+        };
+    }[];
+    sections: {
+        name: string;
+        virtualSize: number;
+        virtualAddress: number;
+        rawSize: number;
+        rawPointer: number;
+    }[];
+    rvaToOffset: (rva: any, size?: number) => any;
+};
+export function parseCliHeader(pe: any): {
+    offset: any;
+    headerSize: number;
+    majorRuntimeVersion: number;
+    minorRuntimeVersion: number;
+    metadataRva: number;
+    metadataSize: number;
+    flags: number;
+    entryPointToken: number;
+    resources: {
+        rva: number;
+        size: number;
+    };
+    strongNameSignature: {
+        rva: number;
+        size: number;
+    };
+    strongNameFlagOffset: any;
+    strongNameDirectoryOffset: any;
+};
+import { MetadataHeaps } from "../metadata/streams.js";

package/src/types/platform/bytes.d.ts

@@ -0,0 +1,3 @@
+export function bytesToBinaryString(bytes: any): string;
+export function binaryStringToBytes(value: any): Uint8Array<any>;
+export function equalBytes(left: any, right: any): boolean;

package/src/types/platform/compression.d.ts

@@ -0,0 +1,2 @@
+export function deflateRawSync(bytes: any): Uint8Array<ArrayBuffer>;
+export function inflateRawSync(bytes: any, options?: {}): Uint8Array<ArrayBuffer>;

package/src/types/platform/crypto.d.ts

@@ -0,0 +1,4 @@
+export function createHash(name: any): {
+    update(bytes: any): /*elided*/ any;
+    digest(): Uint8Array<any>;
+};

package/src/types/resolution/module.d.ts

@@ -0,0 +1,12 @@
+export function resolveTypes(metadata: any, heaps: any): {
+    rid: any;
+    flags: any;
+    name: any;
+    namespace: any;
+    extends: any;
+    fieldRids: any;
+    methodRids: any;
+    eventRids: any[];
+    propertyRids: any[];
+}[];
+export function resolveMethodParameters(metadata: any): any;

package/src/types/writer/patch.d.ts

@@ -0,0 +1,4 @@
+export function applyPatches(bytes: any, patches: any, cliHeader: any, pe: any, { preserveStrongName }?: {
+    preserveStrongName?: boolean;
+}): Uint8Array<ArrayBuffer>;
+export function createOperandPatches(instruction: any, value: any): any;

package/src/types/writer/pe.d.ts

@@ -0,0 +1,9 @@
+export function getNextSectionVirtualAddress(pe: any): number;
+export function appendPeSection(input: any, pe: any, cli: any, payload: any, metadataOffset: any, metadataSize: any, resourcesDirectory?: any, preserveStrongName?: boolean, debugDirectoryPayload?: any): {
+    bytes: Uint8Array<ArrayBuffer>;
+    virtualAddress: number;
+    rawPointer: number;
+    rawSize: number;
+    headerExpansion: number;
+    cliOffset: any;
+};

package/src/types/writer/structural.d.ts

@@ -0,0 +1,4 @@
+export function serializeStructural(assembly: any, { preserveStrongName, strongNameSignatureSize }?: {
+    preserveStrongName?: boolean;
+    strongNameSignatureSize?: number;
+}): Uint8Array<ArrayBuffer>;