objdiff-wasm 2.0.0-beta.4

package/dist/main.d.ts

@@ -0,0 +1,993 @@
+import { MessageType, PartialMessage, IBinaryReader, BinaryReadOptions, IBinaryWriter, BinaryWriteOptions } from '@protobuf-ts/runtime';
+
+/**
+ * Symbol visibility flags
+ *
+ * @generated from protobuf enum objdiff.diff.SymbolFlag
+ */
+declare enum SymbolFlag {
+    /**
+     * @generated from protobuf enum value: SYMBOL_NONE = 0;
+     */
+    SYMBOL_NONE = 0,
+    /**
+     * @generated from protobuf enum value: SYMBOL_GLOBAL = 1;
+     */
+    SYMBOL_GLOBAL = 1,
+    /**
+     * @generated from protobuf enum value: SYMBOL_LOCAL = 2;
+     */
+    SYMBOL_LOCAL = 2,
+    /**
+     * @generated from protobuf enum value: SYMBOL_WEAK = 3;
+     */
+    SYMBOL_WEAK = 3,
+    /**
+     * @generated from protobuf enum value: SYMBOL_COMMON = 4;
+     */
+    SYMBOL_COMMON = 4,
+    /**
+     * @generated from protobuf enum value: SYMBOL_HIDDEN = 5;
+     */
+    SYMBOL_HIDDEN = 5
+}
+/**
+ * @generated from protobuf enum objdiff.diff.DiffKind
+ */
+declare enum DiffKind {
+    /**
+     * @generated from protobuf enum value: DIFF_NONE = 0;
+     */
+    DIFF_NONE = 0,
+    /**
+     * @generated from protobuf enum value: DIFF_REPLACE = 1;
+     */
+    DIFF_REPLACE = 1,
+    /**
+     * @generated from protobuf enum value: DIFF_DELETE = 2;
+     */
+    DIFF_DELETE = 2,
+    /**
+     * @generated from protobuf enum value: DIFF_INSERT = 3;
+     */
+    DIFF_INSERT = 3,
+    /**
+     * @generated from protobuf enum value: DIFF_OP_MISMATCH = 4;
+     */
+    DIFF_OP_MISMATCH = 4,
+    /**
+     * @generated from protobuf enum value: DIFF_ARG_MISMATCH = 5;
+     */
+    DIFF_ARG_MISMATCH = 5
+}
+/**
+ * @generated from protobuf enum objdiff.diff.SectionKind
+ */
+declare enum SectionKind {
+    /**
+     * @generated from protobuf enum value: SECTION_UNKNOWN = 0;
+     */
+    SECTION_UNKNOWN = 0,
+    /**
+     * @generated from protobuf enum value: SECTION_TEXT = 1;
+     */
+    SECTION_TEXT = 1,
+    /**
+     * @generated from protobuf enum value: SECTION_DATA = 2;
+     */
+    SECTION_DATA = 2,
+    /**
+     * @generated from protobuf enum value: SECTION_BSS = 3;
+     */
+    SECTION_BSS = 3,
+    /**
+     * @generated from protobuf enum value: SECTION_COMMON = 4;
+     */
+    SECTION_COMMON = 4
+}
+declare class Symbol$Type extends MessageType<Symbol> {
+    constructor();
+    create(value?: PartialMessage<Symbol>): Symbol;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Symbol): Symbol;
+    internalBinaryWrite(message: Symbol, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * A symbol
+ *
+ * @generated from protobuf message objdiff.diff.Symbol
+ */
+interface Symbol {
+    /**
+     * Name of the symbol
+     *
+     * @generated from protobuf field: string name = 1;
+     */
+    name: string;
+    /**
+     * Demangled name of the symbol
+     *
+     * @generated from protobuf field: optional string demangled_name = 2;
+     */
+    demangled_name?: string;
+    /**
+     * Symbol address
+     *
+     * @generated from protobuf field: uint64 address = 3;
+     */
+    address: bigint;
+    /**
+     * Symbol size
+     *
+     * @generated from protobuf field: uint64 size = 4;
+     */
+    size: bigint;
+    /**
+     * Bitmask of SymbolFlag
+     *
+     * @generated from protobuf field: uint32 flags = 5;
+     */
+    flags: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.Symbol
+ */
+declare const Symbol: Symbol$Type;
+declare class Instruction$Type extends MessageType<Instruction> {
+    constructor();
+    create(value?: PartialMessage<Instruction>): Instruction;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Instruction): Instruction;
+    internalBinaryWrite(message: Instruction, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * A single parsed instruction
+ *
+ * @generated from protobuf message objdiff.diff.Instruction
+ */
+interface Instruction {
+    /**
+     * Instruction address
+     *
+     * @generated from protobuf field: uint64 address = 1;
+     */
+    address: bigint;
+    /**
+     * Instruction size
+     *
+     * @generated from protobuf field: uint32 size = 2;
+     */
+    size: number;
+    /**
+     * Instruction opcode
+     *
+     * @generated from protobuf field: uint32 opcode = 3;
+     */
+    opcode: number;
+    /**
+     * Instruction mnemonic
+     *
+     * @generated from protobuf field: string mnemonic = 4;
+     */
+    mnemonic: string;
+    /**
+     * Instruction formatted string
+     *
+     * @generated from protobuf field: string formatted = 5;
+     */
+    formatted: string;
+    /**
+     * Original (unsimplified) instruction string
+     *
+     * @generated from protobuf field: optional string original = 6;
+     */
+    original?: string;
+    /**
+     * Instruction arguments
+     *
+     * @generated from protobuf field: repeated objdiff.diff.Argument arguments = 7;
+     */
+    arguments: Argument[];
+    /**
+     * Instruction relocation
+     *
+     * @generated from protobuf field: optional objdiff.diff.Relocation relocation = 8;
+     */
+    relocation?: Relocation;
+    /**
+     * Instruction branch destination
+     *
+     * @generated from protobuf field: optional uint64 branch_dest = 9;
+     */
+    branch_dest?: bigint;
+    /**
+     * Instruction line number
+     *
+     * @generated from protobuf field: optional uint32 line_number = 10;
+     */
+    line_number?: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.Instruction
+ */
+declare const Instruction: Instruction$Type;
+declare class Argument$Type extends MessageType<Argument> {
+    constructor();
+    create(value?: PartialMessage<Argument>): Argument;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Argument): Argument;
+    internalBinaryWrite(message: Argument, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * An instruction argument
+ *
+ * @generated from protobuf message objdiff.diff.Argument
+ */
+interface Argument {
+    /**
+     * @generated from protobuf oneof: value
+     */
+    value: {
+        oneofKind: "plain_text";
+        /**
+         * Plain text
+         *
+         * @generated from protobuf field: string plain_text = 1;
+         */
+        plain_text: string;
+    } | {
+        oneofKind: "argument";
+        /**
+         * Value
+         *
+         * @generated from protobuf field: objdiff.diff.ArgumentValue argument = 2;
+         */
+        argument: ArgumentValue;
+    } | {
+        oneofKind: "relocation";
+        /**
+         * Relocation
+         *
+         * @generated from protobuf field: objdiff.diff.ArgumentRelocation relocation = 3;
+         */
+        relocation: ArgumentRelocation;
+    } | {
+        oneofKind: "branch_dest";
+        /**
+         * Branch destination
+         *
+         * @generated from protobuf field: uint64 branch_dest = 4;
+         */
+        branch_dest: bigint;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.Argument
+ */
+declare const Argument: Argument$Type;
+declare class ArgumentValue$Type extends MessageType<ArgumentValue> {
+    constructor();
+    create(value?: PartialMessage<ArgumentValue>): ArgumentValue;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ArgumentValue): ArgumentValue;
+    internalBinaryWrite(message: ArgumentValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * An instruction argument value
+ *
+ * @generated from protobuf message objdiff.diff.ArgumentValue
+ */
+interface ArgumentValue {
+    /**
+     * @generated from protobuf oneof: value
+     */
+    value: {
+        oneofKind: "signed";
+        /**
+         * Signed integer
+         *
+         * @generated from protobuf field: int64 signed = 1;
+         */
+        signed: bigint;
+    } | {
+        oneofKind: "unsigned";
+        /**
+         * Unsigned integer
+         *
+         * @generated from protobuf field: uint64 unsigned = 2;
+         */
+        unsigned: bigint;
+    } | {
+        oneofKind: "opaque";
+        /**
+         * Opaque value
+         *
+         * @generated from protobuf field: string opaque = 3;
+         */
+        opaque: string;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.ArgumentValue
+ */
+declare const ArgumentValue: ArgumentValue$Type;
+declare class ArgumentRelocation$Type extends MessageType<ArgumentRelocation> {
+    constructor();
+    create(value?: PartialMessage<ArgumentRelocation>): ArgumentRelocation;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ArgumentRelocation): ArgumentRelocation;
+    internalBinaryWrite(message: ArgumentRelocation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * Marker type for relocation arguments
+ *
+ * @generated from protobuf message objdiff.diff.ArgumentRelocation
+ */
+interface ArgumentRelocation {
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.ArgumentRelocation
+ */
+declare const ArgumentRelocation: ArgumentRelocation$Type;
+declare class Relocation$Type extends MessageType<Relocation> {
+    constructor();
+    create(value?: PartialMessage<Relocation>): Relocation;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Relocation): Relocation;
+    internalBinaryWrite(message: Relocation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.Relocation
+ */
+interface Relocation {
+    /**
+     * @generated from protobuf field: uint32 type = 1;
+     */
+    type: number;
+    /**
+     * @generated from protobuf field: string type_name = 2;
+     */
+    type_name: string;
+    /**
+     * @generated from protobuf field: objdiff.diff.RelocationTarget target = 3;
+     */
+    target?: RelocationTarget;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.Relocation
+ */
+declare const Relocation: Relocation$Type;
+declare class RelocationTarget$Type extends MessageType<RelocationTarget> {
+    constructor();
+    create(value?: PartialMessage<RelocationTarget>): RelocationTarget;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RelocationTarget): RelocationTarget;
+    internalBinaryWrite(message: RelocationTarget, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.RelocationTarget
+ */
+interface RelocationTarget {
+    /**
+     * @generated from protobuf field: objdiff.diff.Symbol symbol = 1;
+     */
+    symbol?: Symbol;
+    /**
+     * @generated from protobuf field: int64 addend = 2;
+     */
+    addend: bigint;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.RelocationTarget
+ */
+declare const RelocationTarget: RelocationTarget$Type;
+declare class InstructionDiff$Type extends MessageType<InstructionDiff> {
+    constructor();
+    create(value?: PartialMessage<InstructionDiff>): InstructionDiff;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: InstructionDiff): InstructionDiff;
+    internalBinaryWrite(message: InstructionDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.InstructionDiff
+ */
+interface InstructionDiff {
+    /**
+     * @generated from protobuf field: objdiff.diff.DiffKind diff_kind = 1;
+     */
+    diff_kind: DiffKind;
+    /**
+     * @generated from protobuf field: optional objdiff.diff.Instruction instruction = 2;
+     */
+    instruction?: Instruction;
+    /**
+     * @generated from protobuf field: optional objdiff.diff.InstructionBranchFrom branch_from = 3;
+     */
+    branch_from?: InstructionBranchFrom;
+    /**
+     * @generated from protobuf field: optional objdiff.diff.InstructionBranchTo branch_to = 4;
+     */
+    branch_to?: InstructionBranchTo;
+    /**
+     * @generated from protobuf field: repeated objdiff.diff.DiffDisplay display = 5;
+     */
+    display: DiffDisplay[];
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.InstructionDiff
+ */
+declare const InstructionDiff: InstructionDiff$Type;
+declare class InstructionBranchFrom$Type extends MessageType<InstructionBranchFrom> {
+    constructor();
+    create(value?: PartialMessage<InstructionBranchFrom>): InstructionBranchFrom;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: InstructionBranchFrom): InstructionBranchFrom;
+    internalBinaryWrite(message: InstructionBranchFrom, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.InstructionBranchFrom
+ */
+interface InstructionBranchFrom {
+    /**
+     * @generated from protobuf field: repeated uint32 instruction_index = 1;
+     */
+    instruction_index: number[];
+    /**
+     * @generated from protobuf field: uint32 branch_index = 2;
+     */
+    branch_index: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.InstructionBranchFrom
+ */
+declare const InstructionBranchFrom: InstructionBranchFrom$Type;
+declare class InstructionBranchTo$Type extends MessageType<InstructionBranchTo> {
+    constructor();
+    create(value?: PartialMessage<InstructionBranchTo>): InstructionBranchTo;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: InstructionBranchTo): InstructionBranchTo;
+    internalBinaryWrite(message: InstructionBranchTo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.InstructionBranchTo
+ */
+interface InstructionBranchTo {
+    /**
+     * @generated from protobuf field: uint32 instruction_index = 1;
+     */
+    instruction_index: number;
+    /**
+     * @generated from protobuf field: uint32 branch_index = 2;
+     */
+    branch_index: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.InstructionBranchTo
+ */
+declare const InstructionBranchTo: InstructionBranchTo$Type;
+declare class FunctionDiff$Type extends MessageType<FunctionDiff> {
+    constructor();
+    create(value?: PartialMessage<FunctionDiff>): FunctionDiff;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FunctionDiff): FunctionDiff;
+    internalBinaryWrite(message: FunctionDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.FunctionDiff
+ */
+interface FunctionDiff {
+    /**
+     * @generated from protobuf field: objdiff.diff.Symbol symbol = 1;
+     */
+    symbol?: Symbol;
+    /**
+     * @generated from protobuf field: repeated objdiff.diff.InstructionDiff instructions = 2;
+     */
+    instructions: InstructionDiff[];
+    /**
+     * @generated from protobuf field: optional float match_percent = 3;
+     */
+    match_percent?: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.FunctionDiff
+ */
+declare const FunctionDiff: FunctionDiff$Type;
+declare class DataDiff$Type extends MessageType<DataDiff> {
+    constructor();
+    create(value?: PartialMessage<DataDiff>): DataDiff;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DataDiff): DataDiff;
+    internalBinaryWrite(message: DataDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DataDiff
+ */
+interface DataDiff {
+    /**
+     * @generated from protobuf field: objdiff.diff.DiffKind kind = 1;
+     */
+    kind: DiffKind;
+    /**
+     * @generated from protobuf field: bytes data = 2;
+     */
+    data: Uint8Array;
+    /**
+     * May be larger than data
+     *
+     * @generated from protobuf field: uint64 size = 3;
+     */
+    size: bigint;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DataDiff
+ */
+declare const DataDiff: DataDiff$Type;
+declare class SectionDiff$Type extends MessageType<SectionDiff> {
+    constructor();
+    create(value?: PartialMessage<SectionDiff>): SectionDiff;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SectionDiff): SectionDiff;
+    internalBinaryWrite(message: SectionDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.SectionDiff
+ */
+interface SectionDiff {
+    /**
+     * @generated from protobuf field: string name = 1;
+     */
+    name: string;
+    /**
+     * @generated from protobuf field: objdiff.diff.SectionKind kind = 2;
+     */
+    kind: SectionKind;
+    /**
+     * @generated from protobuf field: uint64 size = 3;
+     */
+    size: bigint;
+    /**
+     * @generated from protobuf field: uint64 address = 4;
+     */
+    address: bigint;
+    /**
+     * @generated from protobuf field: repeated objdiff.diff.FunctionDiff functions = 5;
+     */
+    functions: FunctionDiff[];
+    /**
+     * @generated from protobuf field: repeated objdiff.diff.DataDiff data = 6;
+     */
+    data: DataDiff[];
+    /**
+     * @generated from protobuf field: optional float match_percent = 7;
+     */
+    match_percent?: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.SectionDiff
+ */
+declare const SectionDiff: SectionDiff$Type;
+declare class ObjectDiff$Type extends MessageType<ObjectDiff> {
+    constructor();
+    create(value?: PartialMessage<ObjectDiff>): ObjectDiff;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ObjectDiff): ObjectDiff;
+    internalBinaryWrite(message: ObjectDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.ObjectDiff
+ */
+interface ObjectDiff {
+    /**
+     * @generated from protobuf field: repeated objdiff.diff.SectionDiff sections = 1;
+     */
+    sections: SectionDiff[];
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.ObjectDiff
+ */
+declare const ObjectDiff: ObjectDiff$Type;
+declare class DiffResult$Type extends MessageType<DiffResult> {
+    constructor();
+    create(value?: PartialMessage<DiffResult>): DiffResult;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffResult): DiffResult;
+    internalBinaryWrite(message: DiffResult, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffResult
+ */
+interface DiffResult {
+    /**
+     * @generated from protobuf field: optional objdiff.diff.ObjectDiff left = 1;
+     */
+    left?: ObjectDiff;
+    /**
+     * @generated from protobuf field: optional objdiff.diff.ObjectDiff right = 2;
+     */
+    right?: ObjectDiff;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffResult
+ */
+declare const DiffResult: DiffResult$Type;
+declare class DiffDisplay$Type extends MessageType<DiffDisplay> {
+    constructor();
+    create(value?: PartialMessage<DiffDisplay>): DiffDisplay;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffDisplay): DiffDisplay;
+    internalBinaryWrite(message: DiffDisplay, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffDisplay
+ */
+interface DiffDisplay {
+    /**
+     * @generated from protobuf field: objdiff.diff.DiffText text = 1;
+     */
+    text?: DiffText;
+    /**
+     * @generated from protobuf field: optional uint32 diff_index = 2;
+     */
+    diff_index?: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffDisplay
+ */
+declare const DiffDisplay: DiffDisplay$Type;
+declare class DiffText$Type extends MessageType<DiffText> {
+    constructor();
+    create(value?: PartialMessage<DiffText>): DiffText;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffText): DiffText;
+    internalBinaryWrite(message: DiffText, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffText
+ */
+interface DiffText {
+    /**
+     * @generated from protobuf oneof: text
+     */
+    text: {
+        oneofKind: "basic";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextBasic basic = 1;
+         */
+        basic: DiffTextBasic;
+    } | {
+        oneofKind: "basic_color";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextBasicColor basic_color = 2;
+         */
+        basic_color: DiffTextBasicColor;
+    } | {
+        oneofKind: "line";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextLine line = 3;
+         */
+        line: DiffTextLine;
+    } | {
+        oneofKind: "address";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextAddress address = 4;
+         */
+        address: DiffTextAddress;
+    } | {
+        oneofKind: "opcode";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextOpcode opcode = 5;
+         */
+        opcode: DiffTextOpcode;
+    } | {
+        oneofKind: "argument";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextArgument argument = 6;
+         */
+        argument: DiffTextArgument;
+    } | {
+        oneofKind: "branch_dest";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextBranchDest branch_dest = 7;
+         */
+        branch_dest: DiffTextBranchDest;
+    } | {
+        oneofKind: "symbol";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextSymbol symbol = 8;
+         */
+        symbol: DiffTextSymbol;
+    } | {
+        oneofKind: "spacing";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextSpacing spacing = 9;
+         */
+        spacing: DiffTextSpacing;
+    } | {
+        oneofKind: "eol";
+        /**
+         * @generated from protobuf field: objdiff.diff.DiffTextEol eol = 10;
+         */
+        eol: DiffTextEol;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffText
+ */
+declare const DiffText: DiffText$Type;
+declare class DiffTextBasic$Type extends MessageType<DiffTextBasic> {
+    constructor();
+    create(value?: PartialMessage<DiffTextBasic>): DiffTextBasic;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextBasic): DiffTextBasic;
+    internalBinaryWrite(message: DiffTextBasic, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextBasic
+ */
+interface DiffTextBasic {
+    /**
+     * @generated from protobuf field: string text = 1;
+     */
+    text: string;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextBasic
+ */
+declare const DiffTextBasic: DiffTextBasic$Type;
+declare class DiffTextBasicColor$Type extends MessageType<DiffTextBasicColor> {
+    constructor();
+    create(value?: PartialMessage<DiffTextBasicColor>): DiffTextBasicColor;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextBasicColor): DiffTextBasicColor;
+    internalBinaryWrite(message: DiffTextBasicColor, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextBasicColor
+ */
+interface DiffTextBasicColor {
+    /**
+     * @generated from protobuf field: string text = 1;
+     */
+    text: string;
+    /**
+     * @generated from protobuf field: uint32 index = 2;
+     */
+    index: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextBasicColor
+ */
+declare const DiffTextBasicColor: DiffTextBasicColor$Type;
+declare class DiffTextLine$Type extends MessageType<DiffTextLine> {
+    constructor();
+    create(value?: PartialMessage<DiffTextLine>): DiffTextLine;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextLine): DiffTextLine;
+    internalBinaryWrite(message: DiffTextLine, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextLine
+ */
+interface DiffTextLine {
+    /**
+     * @generated from protobuf field: uint32 line_number = 1;
+     */
+    line_number: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextLine
+ */
+declare const DiffTextLine: DiffTextLine$Type;
+declare class DiffTextAddress$Type extends MessageType<DiffTextAddress> {
+    constructor();
+    create(value?: PartialMessage<DiffTextAddress>): DiffTextAddress;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextAddress): DiffTextAddress;
+    internalBinaryWrite(message: DiffTextAddress, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextAddress
+ */
+interface DiffTextAddress {
+    /**
+     * @generated from protobuf field: uint64 address = 1;
+     */
+    address: bigint;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextAddress
+ */
+declare const DiffTextAddress: DiffTextAddress$Type;
+declare class DiffTextOpcode$Type extends MessageType<DiffTextOpcode> {
+    constructor();
+    create(value?: PartialMessage<DiffTextOpcode>): DiffTextOpcode;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextOpcode): DiffTextOpcode;
+    internalBinaryWrite(message: DiffTextOpcode, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextOpcode
+ */
+interface DiffTextOpcode {
+    /**
+     * @generated from protobuf field: string mnemonic = 1;
+     */
+    mnemonic: string;
+    /**
+     * @generated from protobuf field: uint32 opcode = 2;
+     */
+    opcode: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextOpcode
+ */
+declare const DiffTextOpcode: DiffTextOpcode$Type;
+declare class DiffTextArgument$Type extends MessageType<DiffTextArgument> {
+    constructor();
+    create(value?: PartialMessage<DiffTextArgument>): DiffTextArgument;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextArgument): DiffTextArgument;
+    internalBinaryWrite(message: DiffTextArgument, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextArgument
+ */
+interface DiffTextArgument {
+    /**
+     * @generated from protobuf field: objdiff.diff.ArgumentValue value = 1;
+     */
+    value?: ArgumentValue;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextArgument
+ */
+declare const DiffTextArgument: DiffTextArgument$Type;
+declare class DiffTextBranchDest$Type extends MessageType<DiffTextBranchDest> {
+    constructor();
+    create(value?: PartialMessage<DiffTextBranchDest>): DiffTextBranchDest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextBranchDest): DiffTextBranchDest;
+    internalBinaryWrite(message: DiffTextBranchDest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextBranchDest
+ */
+interface DiffTextBranchDest {
+    /**
+     * @generated from protobuf field: uint64 address = 1;
+     */
+    address: bigint;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextBranchDest
+ */
+declare const DiffTextBranchDest: DiffTextBranchDest$Type;
+declare class DiffTextSymbol$Type extends MessageType<DiffTextSymbol> {
+    constructor();
+    create(value?: PartialMessage<DiffTextSymbol>): DiffTextSymbol;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextSymbol): DiffTextSymbol;
+    internalBinaryWrite(message: DiffTextSymbol, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextSymbol
+ */
+interface DiffTextSymbol {
+    /**
+     * @generated from protobuf field: objdiff.diff.RelocationTarget target = 1;
+     */
+    target?: RelocationTarget;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextSymbol
+ */
+declare const DiffTextSymbol: DiffTextSymbol$Type;
+declare class DiffTextSpacing$Type extends MessageType<DiffTextSpacing> {
+    constructor();
+    create(value?: PartialMessage<DiffTextSpacing>): DiffTextSpacing;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextSpacing): DiffTextSpacing;
+    internalBinaryWrite(message: DiffTextSpacing, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextSpacing
+ */
+interface DiffTextSpacing {
+    /**
+     * @generated from protobuf field: uint32 count = 1;
+     */
+    count: number;
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextSpacing
+ */
+declare const DiffTextSpacing: DiffTextSpacing$Type;
+declare class DiffTextEol$Type extends MessageType<DiffTextEol> {
+    constructor();
+    create(value?: PartialMessage<DiffTextEol>): DiffTextEol;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffTextEol): DiffTextEol;
+    internalBinaryWrite(message: DiffTextEol, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated from protobuf message objdiff.diff.DiffTextEol
+ */
+interface DiffTextEol {
+}
+/**
+ * @generated MessageType for protobuf message objdiff.diff.DiffTextEol
+ */
+declare const DiffTextEol: DiffTextEol$Type;
+
+/**
+*/
+declare enum ArmR9Usage {
+  GeneralPurpose = 0,
+  Sb = 1,
+  Tr = 2,
+}
+/**
+*/
+declare enum MipsAbi {
+  Auto = 0,
+  O32 = 1,
+  N32 = 2,
+  N64 = 3,
+}
+/**
+*/
+declare enum X86Formatter {
+  Intel = 0,
+  Gas = 1,
+  Nasm = 2,
+  Masm = 3,
+}
+/**
+*/
+declare enum ArmArchVersion {
+  Auto = 0,
+  V4T = 1,
+  V5TE = 2,
+  V6K = 3,
+}
+/**
+*/
+declare enum MipsInstrCategory {
+  Auto = 0,
+  Cpu = 1,
+  Rsp = 2,
+  R3000Gte = 3,
+  R4000Allegrex = 4,
+  R5900 = 5,
+}
+/**
+*/
+declare class DiffObjConfig$1 {
+  free(): void;
+/**
+*/
+  arm_arch_version: ArmArchVersion;
+/**
+*/
+  arm_av_registers: boolean;
+/**
+*/
+  arm_fp_usage: boolean;
+/**
+*/
+  arm_ip_usage: boolean;
+/**
+*/
+  arm_r9_usage: ArmR9Usage;
+/**
+*/
+  arm_sl_usage: boolean;
+/**
+*/
+  arm_unified_syntax: boolean;
+/**
+*/
+  combine_data_sections: boolean;
+/**
+*/
+  mips_abi: MipsAbi;
+/**
+*/
+  mips_instr_category: MipsInstrCategory;
+/**
+*/
+  relax_reloc_diffs: boolean;
+/**
+*/
+  space_between_args: boolean;
+/**
+*/
+  x86_formatter: X86Formatter;
+}
+
+type DiffObjConfig = Omit<Partial<DiffObjConfig$1>, 'free'>;
+
+declare function initialize(workerUrl?: string | URL): void;
+declare function runDiff(left: Uint8Array | undefined, right: Uint8Array | undefined, config?: DiffObjConfig): Promise<DiffResult>;
+
+export { Argument, ArgumentRelocation, ArgumentValue, ArmArchVersion, ArmR9Usage, DataDiff, DiffKind, type DiffObjConfig, DiffResult, Instruction, InstructionBranchFrom, InstructionBranchTo, InstructionDiff, MipsAbi, MipsInstrCategory, ObjectDiff, Relocation, RelocationTarget, SectionDiff, SectionKind, Symbol, SymbolFlag, X86Formatter, initialize, runDiff };