github.com/hyperledger/burrow@v0.34.5-0.20220512172541-77f09336001d/js/proto/tendermint/crypto/proof_pb.d.ts (about)

     1  // package: tendermint.crypto
     2  // file: tendermint/crypto/proof.proto
     3  
     4  /* tslint:disable */
     5  /* eslint-disable */
     6  
     7  import * as jspb from "google-protobuf";
     8  import * as gogoproto_gogo_pb from "../../gogoproto/gogo_pb";
     9  
    10  export class Proof extends jspb.Message { 
    11      getTotal(): number;
    12      setTotal(value: number): Proof;
    13      getIndex(): number;
    14      setIndex(value: number): Proof;
    15      getLeafHash(): Uint8Array | string;
    16      getLeafHash_asU8(): Uint8Array;
    17      getLeafHash_asB64(): string;
    18      setLeafHash(value: Uint8Array | string): Proof;
    19      clearAuntsList(): void;
    20      getAuntsList(): Array<Uint8Array | string>;
    21      getAuntsList_asU8(): Array<Uint8Array>;
    22      getAuntsList_asB64(): Array<string>;
    23      setAuntsList(value: Array<Uint8Array | string>): Proof;
    24      addAunts(value: Uint8Array | string, index?: number): Uint8Array | string;
    25  
    26      serializeBinary(): Uint8Array;
    27      toObject(includeInstance?: boolean): Proof.AsObject;
    28      static toObject(includeInstance: boolean, msg: Proof): Proof.AsObject;
    29      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    30      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    31      static serializeBinaryToWriter(message: Proof, writer: jspb.BinaryWriter): void;
    32      static deserializeBinary(bytes: Uint8Array): Proof;
    33      static deserializeBinaryFromReader(message: Proof, reader: jspb.BinaryReader): Proof;
    34  }
    35  
    36  export namespace Proof {
    37      export type AsObject = {
    38          total: number,
    39          index: number,
    40          leafHash: Uint8Array | string,
    41          auntsList: Array<Uint8Array | string>,
    42      }
    43  }
    44  
    45  export class ValueOp extends jspb.Message { 
    46      getKey(): Uint8Array | string;
    47      getKey_asU8(): Uint8Array;
    48      getKey_asB64(): string;
    49      setKey(value: Uint8Array | string): ValueOp;
    50  
    51      hasProof(): boolean;
    52      clearProof(): void;
    53      getProof(): Proof | undefined;
    54      setProof(value?: Proof): ValueOp;
    55  
    56      serializeBinary(): Uint8Array;
    57      toObject(includeInstance?: boolean): ValueOp.AsObject;
    58      static toObject(includeInstance: boolean, msg: ValueOp): ValueOp.AsObject;
    59      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    60      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    61      static serializeBinaryToWriter(message: ValueOp, writer: jspb.BinaryWriter): void;
    62      static deserializeBinary(bytes: Uint8Array): ValueOp;
    63      static deserializeBinaryFromReader(message: ValueOp, reader: jspb.BinaryReader): ValueOp;
    64  }
    65  
    66  export namespace ValueOp {
    67      export type AsObject = {
    68          key: Uint8Array | string,
    69          proof?: Proof.AsObject,
    70      }
    71  }
    72  
    73  export class DominoOp extends jspb.Message { 
    74      getKey(): string;
    75      setKey(value: string): DominoOp;
    76      getInput(): string;
    77      setInput(value: string): DominoOp;
    78      getOutput(): string;
    79      setOutput(value: string): DominoOp;
    80  
    81      serializeBinary(): Uint8Array;
    82      toObject(includeInstance?: boolean): DominoOp.AsObject;
    83      static toObject(includeInstance: boolean, msg: DominoOp): DominoOp.AsObject;
    84      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    85      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    86      static serializeBinaryToWriter(message: DominoOp, writer: jspb.BinaryWriter): void;
    87      static deserializeBinary(bytes: Uint8Array): DominoOp;
    88      static deserializeBinaryFromReader(message: DominoOp, reader: jspb.BinaryReader): DominoOp;
    89  }
    90  
    91  export namespace DominoOp {
    92      export type AsObject = {
    93          key: string,
    94          input: string,
    95          output: string,
    96      }
    97  }
    98  
    99  export class ProofOp extends jspb.Message { 
   100      getType(): string;
   101      setType(value: string): ProofOp;
   102      getKey(): Uint8Array | string;
   103      getKey_asU8(): Uint8Array;
   104      getKey_asB64(): string;
   105      setKey(value: Uint8Array | string): ProofOp;
   106      getData(): Uint8Array | string;
   107      getData_asU8(): Uint8Array;
   108      getData_asB64(): string;
   109      setData(value: Uint8Array | string): ProofOp;
   110  
   111      serializeBinary(): Uint8Array;
   112      toObject(includeInstance?: boolean): ProofOp.AsObject;
   113      static toObject(includeInstance: boolean, msg: ProofOp): ProofOp.AsObject;
   114      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   115      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   116      static serializeBinaryToWriter(message: ProofOp, writer: jspb.BinaryWriter): void;
   117      static deserializeBinary(bytes: Uint8Array): ProofOp;
   118      static deserializeBinaryFromReader(message: ProofOp, reader: jspb.BinaryReader): ProofOp;
   119  }
   120  
   121  export namespace ProofOp {
   122      export type AsObject = {
   123          type: string,
   124          key: Uint8Array | string,
   125          data: Uint8Array | string,
   126      }
   127  }
   128  
   129  export class ProofOps extends jspb.Message { 
   130      clearOpsList(): void;
   131      getOpsList(): Array<ProofOp>;
   132      setOpsList(value: Array<ProofOp>): ProofOps;
   133      addOps(value?: ProofOp, index?: number): ProofOp;
   134  
   135      serializeBinary(): Uint8Array;
   136      toObject(includeInstance?: boolean): ProofOps.AsObject;
   137      static toObject(includeInstance: boolean, msg: ProofOps): ProofOps.AsObject;
   138      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   139      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   140      static serializeBinaryToWriter(message: ProofOps, writer: jspb.BinaryWriter): void;
   141      static deserializeBinary(bytes: Uint8Array): ProofOps;
   142      static deserializeBinaryFromReader(message: ProofOps, reader: jspb.BinaryReader): ProofOps;
   143  }
   144  
   145  export namespace ProofOps {
   146      export type AsObject = {
   147          opsList: Array<ProofOp.AsObject>,
   148      }
   149  }