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

     1  // package: payload
     2  // file: payload.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  import * as permission_pb from "./permission_pb";
    10  import * as registry_pb from "./registry_pb";
    11  import * as spec_pb from "./spec_pb";
    12  
    13  export class Any extends jspb.Message { 
    14  
    15      hasCalltx(): boolean;
    16      clearCalltx(): void;
    17      getCalltx(): CallTx | undefined;
    18      setCalltx(value?: CallTx): Any;
    19  
    20      hasSendtx(): boolean;
    21      clearSendtx(): void;
    22      getSendtx(): SendTx | undefined;
    23      setSendtx(value?: SendTx): Any;
    24  
    25      hasNametx(): boolean;
    26      clearNametx(): void;
    27      getNametx(): NameTx | undefined;
    28      setNametx(value?: NameTx): Any;
    29  
    30      hasPermstx(): boolean;
    31      clearPermstx(): void;
    32      getPermstx(): PermsTx | undefined;
    33      setPermstx(value?: PermsTx): Any;
    34  
    35      hasGovtx(): boolean;
    36      clearGovtx(): void;
    37      getGovtx(): GovTx | undefined;
    38      setGovtx(value?: GovTx): Any;
    39  
    40      hasBondtx(): boolean;
    41      clearBondtx(): void;
    42      getBondtx(): BondTx | undefined;
    43      setBondtx(value?: BondTx): Any;
    44  
    45      hasUnbondtx(): boolean;
    46      clearUnbondtx(): void;
    47      getUnbondtx(): UnbondTx | undefined;
    48      setUnbondtx(value?: UnbondTx): Any;
    49  
    50      hasBatchtx(): boolean;
    51      clearBatchtx(): void;
    52      getBatchtx(): BatchTx | undefined;
    53      setBatchtx(value?: BatchTx): Any;
    54  
    55      hasProposaltx(): boolean;
    56      clearProposaltx(): void;
    57      getProposaltx(): ProposalTx | undefined;
    58      setProposaltx(value?: ProposalTx): Any;
    59  
    60      hasIdentifytx(): boolean;
    61      clearIdentifytx(): void;
    62      getIdentifytx(): IdentifyTx | undefined;
    63      setIdentifytx(value?: IdentifyTx): Any;
    64  
    65      serializeBinary(): Uint8Array;
    66      toObject(includeInstance?: boolean): Any.AsObject;
    67      static toObject(includeInstance: boolean, msg: Any): Any.AsObject;
    68      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    69      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    70      static serializeBinaryToWriter(message: Any, writer: jspb.BinaryWriter): void;
    71      static deserializeBinary(bytes: Uint8Array): Any;
    72      static deserializeBinaryFromReader(message: Any, reader: jspb.BinaryReader): Any;
    73  }
    74  
    75  export namespace Any {
    76      export type AsObject = {
    77          calltx?: CallTx.AsObject,
    78          sendtx?: SendTx.AsObject,
    79          nametx?: NameTx.AsObject,
    80          permstx?: PermsTx.AsObject,
    81          govtx?: GovTx.AsObject,
    82          bondtx?: BondTx.AsObject,
    83          unbondtx?: UnbondTx.AsObject,
    84          batchtx?: BatchTx.AsObject,
    85          proposaltx?: ProposalTx.AsObject,
    86          identifytx?: IdentifyTx.AsObject,
    87      }
    88  }
    89  
    90  export class TxInput extends jspb.Message { 
    91      getAddress(): Uint8Array | string;
    92      getAddress_asU8(): Uint8Array;
    93      getAddress_asB64(): string;
    94      setAddress(value: Uint8Array | string): TxInput;
    95      getAmount(): number;
    96      setAmount(value: number): TxInput;
    97      getSequence(): number;
    98      setSequence(value: number): TxInput;
    99  
   100      serializeBinary(): Uint8Array;
   101      toObject(includeInstance?: boolean): TxInput.AsObject;
   102      static toObject(includeInstance: boolean, msg: TxInput): TxInput.AsObject;
   103      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   104      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   105      static serializeBinaryToWriter(message: TxInput, writer: jspb.BinaryWriter): void;
   106      static deserializeBinary(bytes: Uint8Array): TxInput;
   107      static deserializeBinaryFromReader(message: TxInput, reader: jspb.BinaryReader): TxInput;
   108  }
   109  
   110  export namespace TxInput {
   111      export type AsObject = {
   112          address: Uint8Array | string,
   113          amount: number,
   114          sequence: number,
   115      }
   116  }
   117  
   118  export class TxOutput extends jspb.Message { 
   119      getAddress(): Uint8Array | string;
   120      getAddress_asU8(): Uint8Array;
   121      getAddress_asB64(): string;
   122      setAddress(value: Uint8Array | string): TxOutput;
   123      getAmount(): number;
   124      setAmount(value: number): TxOutput;
   125  
   126      serializeBinary(): Uint8Array;
   127      toObject(includeInstance?: boolean): TxOutput.AsObject;
   128      static toObject(includeInstance: boolean, msg: TxOutput): TxOutput.AsObject;
   129      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   130      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   131      static serializeBinaryToWriter(message: TxOutput, writer: jspb.BinaryWriter): void;
   132      static deserializeBinary(bytes: Uint8Array): TxOutput;
   133      static deserializeBinaryFromReader(message: TxOutput, reader: jspb.BinaryReader): TxOutput;
   134  }
   135  
   136  export namespace TxOutput {
   137      export type AsObject = {
   138          address: Uint8Array | string,
   139          amount: number,
   140      }
   141  }
   142  
   143  export class CallTx extends jspb.Message { 
   144  
   145      hasInput(): boolean;
   146      clearInput(): void;
   147      getInput(): TxInput | undefined;
   148      setInput(value?: TxInput): CallTx;
   149      getAddress(): Uint8Array | string;
   150      getAddress_asU8(): Uint8Array;
   151      getAddress_asB64(): string;
   152      setAddress(value: Uint8Array | string): CallTx;
   153      getGaslimit(): number;
   154      setGaslimit(value: number): CallTx;
   155      getFee(): number;
   156      setFee(value: number): CallTx;
   157      getData(): Uint8Array | string;
   158      getData_asU8(): Uint8Array;
   159      getData_asB64(): string;
   160      setData(value: Uint8Array | string): CallTx;
   161      getWasm(): Uint8Array | string;
   162      getWasm_asU8(): Uint8Array;
   163      getWasm_asB64(): string;
   164      setWasm(value: Uint8Array | string): CallTx;
   165      clearContractmetaList(): void;
   166      getContractmetaList(): Array<ContractMeta>;
   167      setContractmetaList(value: Array<ContractMeta>): CallTx;
   168      addContractmeta(value?: ContractMeta, index?: number): ContractMeta;
   169      getGasprice(): number;
   170      setGasprice(value: number): CallTx;
   171  
   172      serializeBinary(): Uint8Array;
   173      toObject(includeInstance?: boolean): CallTx.AsObject;
   174      static toObject(includeInstance: boolean, msg: CallTx): CallTx.AsObject;
   175      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   176      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   177      static serializeBinaryToWriter(message: CallTx, writer: jspb.BinaryWriter): void;
   178      static deserializeBinary(bytes: Uint8Array): CallTx;
   179      static deserializeBinaryFromReader(message: CallTx, reader: jspb.BinaryReader): CallTx;
   180  }
   181  
   182  export namespace CallTx {
   183      export type AsObject = {
   184          input?: TxInput.AsObject,
   185          address: Uint8Array | string,
   186          gaslimit: number,
   187          fee: number,
   188          data: Uint8Array | string,
   189          wasm: Uint8Array | string,
   190          contractmetaList: Array<ContractMeta.AsObject>,
   191          gasprice: number,
   192      }
   193  }
   194  
   195  export class ContractMeta extends jspb.Message { 
   196      getCodehash(): Uint8Array | string;
   197      getCodehash_asU8(): Uint8Array;
   198      getCodehash_asB64(): string;
   199      setCodehash(value: Uint8Array | string): ContractMeta;
   200      getMeta(): string;
   201      setMeta(value: string): ContractMeta;
   202  
   203      serializeBinary(): Uint8Array;
   204      toObject(includeInstance?: boolean): ContractMeta.AsObject;
   205      static toObject(includeInstance: boolean, msg: ContractMeta): ContractMeta.AsObject;
   206      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   207      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   208      static serializeBinaryToWriter(message: ContractMeta, writer: jspb.BinaryWriter): void;
   209      static deserializeBinary(bytes: Uint8Array): ContractMeta;
   210      static deserializeBinaryFromReader(message: ContractMeta, reader: jspb.BinaryReader): ContractMeta;
   211  }
   212  
   213  export namespace ContractMeta {
   214      export type AsObject = {
   215          codehash: Uint8Array | string,
   216          meta: string,
   217      }
   218  }
   219  
   220  export class SendTx extends jspb.Message { 
   221      clearInputsList(): void;
   222      getInputsList(): Array<TxInput>;
   223      setInputsList(value: Array<TxInput>): SendTx;
   224      addInputs(value?: TxInput, index?: number): TxInput;
   225      clearOutputsList(): void;
   226      getOutputsList(): Array<TxOutput>;
   227      setOutputsList(value: Array<TxOutput>): SendTx;
   228      addOutputs(value?: TxOutput, index?: number): TxOutput;
   229  
   230      serializeBinary(): Uint8Array;
   231      toObject(includeInstance?: boolean): SendTx.AsObject;
   232      static toObject(includeInstance: boolean, msg: SendTx): SendTx.AsObject;
   233      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   234      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   235      static serializeBinaryToWriter(message: SendTx, writer: jspb.BinaryWriter): void;
   236      static deserializeBinary(bytes: Uint8Array): SendTx;
   237      static deserializeBinaryFromReader(message: SendTx, reader: jspb.BinaryReader): SendTx;
   238  }
   239  
   240  export namespace SendTx {
   241      export type AsObject = {
   242          inputsList: Array<TxInput.AsObject>,
   243          outputsList: Array<TxOutput.AsObject>,
   244      }
   245  }
   246  
   247  export class PermsTx extends jspb.Message { 
   248  
   249      hasInput(): boolean;
   250      clearInput(): void;
   251      getInput(): TxInput | undefined;
   252      setInput(value?: TxInput): PermsTx;
   253  
   254      hasPermargs(): boolean;
   255      clearPermargs(): void;
   256      getPermargs(): permission_pb.PermArgs | undefined;
   257      setPermargs(value?: permission_pb.PermArgs): PermsTx;
   258  
   259      serializeBinary(): Uint8Array;
   260      toObject(includeInstance?: boolean): PermsTx.AsObject;
   261      static toObject(includeInstance: boolean, msg: PermsTx): PermsTx.AsObject;
   262      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   263      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   264      static serializeBinaryToWriter(message: PermsTx, writer: jspb.BinaryWriter): void;
   265      static deserializeBinary(bytes: Uint8Array): PermsTx;
   266      static deserializeBinaryFromReader(message: PermsTx, reader: jspb.BinaryReader): PermsTx;
   267  }
   268  
   269  export namespace PermsTx {
   270      export type AsObject = {
   271          input?: TxInput.AsObject,
   272          permargs?: permission_pb.PermArgs.AsObject,
   273      }
   274  }
   275  
   276  export class NameTx extends jspb.Message { 
   277  
   278      hasInput(): boolean;
   279      clearInput(): void;
   280      getInput(): TxInput | undefined;
   281      setInput(value?: TxInput): NameTx;
   282      getName(): string;
   283      setName(value: string): NameTx;
   284      getData(): string;
   285      setData(value: string): NameTx;
   286      getFee(): number;
   287      setFee(value: number): NameTx;
   288  
   289      serializeBinary(): Uint8Array;
   290      toObject(includeInstance?: boolean): NameTx.AsObject;
   291      static toObject(includeInstance: boolean, msg: NameTx): NameTx.AsObject;
   292      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   293      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   294      static serializeBinaryToWriter(message: NameTx, writer: jspb.BinaryWriter): void;
   295      static deserializeBinary(bytes: Uint8Array): NameTx;
   296      static deserializeBinaryFromReader(message: NameTx, reader: jspb.BinaryReader): NameTx;
   297  }
   298  
   299  export namespace NameTx {
   300      export type AsObject = {
   301          input?: TxInput.AsObject,
   302          name: string,
   303          data: string,
   304          fee: number,
   305      }
   306  }
   307  
   308  export class BondTx extends jspb.Message { 
   309  
   310      hasInput(): boolean;
   311      clearInput(): void;
   312      getInput(): TxInput | undefined;
   313      setInput(value?: TxInput): BondTx;
   314  
   315      serializeBinary(): Uint8Array;
   316      toObject(includeInstance?: boolean): BondTx.AsObject;
   317      static toObject(includeInstance: boolean, msg: BondTx): BondTx.AsObject;
   318      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   319      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   320      static serializeBinaryToWriter(message: BondTx, writer: jspb.BinaryWriter): void;
   321      static deserializeBinary(bytes: Uint8Array): BondTx;
   322      static deserializeBinaryFromReader(message: BondTx, reader: jspb.BinaryReader): BondTx;
   323  }
   324  
   325  export namespace BondTx {
   326      export type AsObject = {
   327          input?: TxInput.AsObject,
   328      }
   329  }
   330  
   331  export class UnbondTx extends jspb.Message { 
   332  
   333      hasInput(): boolean;
   334      clearInput(): void;
   335      getInput(): TxInput | undefined;
   336      setInput(value?: TxInput): UnbondTx;
   337  
   338      hasOutput(): boolean;
   339      clearOutput(): void;
   340      getOutput(): TxOutput | undefined;
   341      setOutput(value?: TxOutput): UnbondTx;
   342  
   343      serializeBinary(): Uint8Array;
   344      toObject(includeInstance?: boolean): UnbondTx.AsObject;
   345      static toObject(includeInstance: boolean, msg: UnbondTx): UnbondTx.AsObject;
   346      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   347      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   348      static serializeBinaryToWriter(message: UnbondTx, writer: jspb.BinaryWriter): void;
   349      static deserializeBinary(bytes: Uint8Array): UnbondTx;
   350      static deserializeBinaryFromReader(message: UnbondTx, reader: jspb.BinaryReader): UnbondTx;
   351  }
   352  
   353  export namespace UnbondTx {
   354      export type AsObject = {
   355          input?: TxInput.AsObject,
   356          output?: TxOutput.AsObject,
   357      }
   358  }
   359  
   360  export class GovTx extends jspb.Message { 
   361      clearInputsList(): void;
   362      getInputsList(): Array<TxInput>;
   363      setInputsList(value: Array<TxInput>): GovTx;
   364      addInputs(value?: TxInput, index?: number): TxInput;
   365      clearAccountupdatesList(): void;
   366      getAccountupdatesList(): Array<spec_pb.TemplateAccount>;
   367      setAccountupdatesList(value: Array<spec_pb.TemplateAccount>): GovTx;
   368      addAccountupdates(value?: spec_pb.TemplateAccount, index?: number): spec_pb.TemplateAccount;
   369  
   370      serializeBinary(): Uint8Array;
   371      toObject(includeInstance?: boolean): GovTx.AsObject;
   372      static toObject(includeInstance: boolean, msg: GovTx): GovTx.AsObject;
   373      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   374      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   375      static serializeBinaryToWriter(message: GovTx, writer: jspb.BinaryWriter): void;
   376      static deserializeBinary(bytes: Uint8Array): GovTx;
   377      static deserializeBinaryFromReader(message: GovTx, reader: jspb.BinaryReader): GovTx;
   378  }
   379  
   380  export namespace GovTx {
   381      export type AsObject = {
   382          inputsList: Array<TxInput.AsObject>,
   383          accountupdatesList: Array<spec_pb.TemplateAccount.AsObject>,
   384      }
   385  }
   386  
   387  export class ProposalTx extends jspb.Message { 
   388  
   389      hasInput(): boolean;
   390      clearInput(): void;
   391      getInput(): TxInput | undefined;
   392      setInput(value?: TxInput): ProposalTx;
   393      getVotingweight(): number;
   394      setVotingweight(value: number): ProposalTx;
   395      getProposalhash(): Uint8Array | string;
   396      getProposalhash_asU8(): Uint8Array;
   397      getProposalhash_asB64(): string;
   398      setProposalhash(value: Uint8Array | string): ProposalTx;
   399  
   400      hasProposal(): boolean;
   401      clearProposal(): void;
   402      getProposal(): Proposal | undefined;
   403      setProposal(value?: Proposal): ProposalTx;
   404  
   405      serializeBinary(): Uint8Array;
   406      toObject(includeInstance?: boolean): ProposalTx.AsObject;
   407      static toObject(includeInstance: boolean, msg: ProposalTx): ProposalTx.AsObject;
   408      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   409      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   410      static serializeBinaryToWriter(message: ProposalTx, writer: jspb.BinaryWriter): void;
   411      static deserializeBinary(bytes: Uint8Array): ProposalTx;
   412      static deserializeBinaryFromReader(message: ProposalTx, reader: jspb.BinaryReader): ProposalTx;
   413  }
   414  
   415  export namespace ProposalTx {
   416      export type AsObject = {
   417          input?: TxInput.AsObject,
   418          votingweight: number,
   419          proposalhash: Uint8Array | string,
   420          proposal?: Proposal.AsObject,
   421      }
   422  }
   423  
   424  export class IdentifyTx extends jspb.Message { 
   425      clearInputsList(): void;
   426      getInputsList(): Array<TxInput>;
   427      setInputsList(value: Array<TxInput>): IdentifyTx;
   428      addInputs(value?: TxInput, index?: number): TxInput;
   429  
   430      hasNode(): boolean;
   431      clearNode(): void;
   432      getNode(): registry_pb.NodeIdentity | undefined;
   433      setNode(value?: registry_pb.NodeIdentity): IdentifyTx;
   434  
   435      serializeBinary(): Uint8Array;
   436      toObject(includeInstance?: boolean): IdentifyTx.AsObject;
   437      static toObject(includeInstance: boolean, msg: IdentifyTx): IdentifyTx.AsObject;
   438      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   439      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   440      static serializeBinaryToWriter(message: IdentifyTx, writer: jspb.BinaryWriter): void;
   441      static deserializeBinary(bytes: Uint8Array): IdentifyTx;
   442      static deserializeBinaryFromReader(message: IdentifyTx, reader: jspb.BinaryReader): IdentifyTx;
   443  }
   444  
   445  export namespace IdentifyTx {
   446      export type AsObject = {
   447          inputsList: Array<TxInput.AsObject>,
   448          node?: registry_pb.NodeIdentity.AsObject,
   449      }
   450  }
   451  
   452  export class BatchTx extends jspb.Message { 
   453      clearInputsList(): void;
   454      getInputsList(): Array<TxInput>;
   455      setInputsList(value: Array<TxInput>): BatchTx;
   456      addInputs(value?: TxInput, index?: number): TxInput;
   457      clearTxsList(): void;
   458      getTxsList(): Array<Any>;
   459      setTxsList(value: Array<Any>): BatchTx;
   460      addTxs(value?: Any, index?: number): Any;
   461  
   462      serializeBinary(): Uint8Array;
   463      toObject(includeInstance?: boolean): BatchTx.AsObject;
   464      static toObject(includeInstance: boolean, msg: BatchTx): BatchTx.AsObject;
   465      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   466      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   467      static serializeBinaryToWriter(message: BatchTx, writer: jspb.BinaryWriter): void;
   468      static deserializeBinary(bytes: Uint8Array): BatchTx;
   469      static deserializeBinaryFromReader(message: BatchTx, reader: jspb.BinaryReader): BatchTx;
   470  }
   471  
   472  export namespace BatchTx {
   473      export type AsObject = {
   474          inputsList: Array<TxInput.AsObject>,
   475          txsList: Array<Any.AsObject>,
   476      }
   477  }
   478  
   479  export class Vote extends jspb.Message { 
   480      getAddress(): Uint8Array | string;
   481      getAddress_asU8(): Uint8Array;
   482      getAddress_asB64(): string;
   483      setAddress(value: Uint8Array | string): Vote;
   484      getVotingweight(): number;
   485      setVotingweight(value: number): Vote;
   486  
   487      serializeBinary(): Uint8Array;
   488      toObject(includeInstance?: boolean): Vote.AsObject;
   489      static toObject(includeInstance: boolean, msg: Vote): Vote.AsObject;
   490      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   491      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   492      static serializeBinaryToWriter(message: Vote, writer: jspb.BinaryWriter): void;
   493      static deserializeBinary(bytes: Uint8Array): Vote;
   494      static deserializeBinaryFromReader(message: Vote, reader: jspb.BinaryReader): Vote;
   495  }
   496  
   497  export namespace Vote {
   498      export type AsObject = {
   499          address: Uint8Array | string,
   500          votingweight: number,
   501      }
   502  }
   503  
   504  export class Proposal extends jspb.Message { 
   505      getName(): string;
   506      setName(value: string): Proposal;
   507      getDescription(): string;
   508      setDescription(value: string): Proposal;
   509  
   510      hasBatchtx(): boolean;
   511      clearBatchtx(): void;
   512      getBatchtx(): BatchTx | undefined;
   513      setBatchtx(value?: BatchTx): Proposal;
   514  
   515      serializeBinary(): Uint8Array;
   516      toObject(includeInstance?: boolean): Proposal.AsObject;
   517      static toObject(includeInstance: boolean, msg: Proposal): Proposal.AsObject;
   518      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   519      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   520      static serializeBinaryToWriter(message: Proposal, writer: jspb.BinaryWriter): void;
   521      static deserializeBinary(bytes: Uint8Array): Proposal;
   522      static deserializeBinaryFromReader(message: Proposal, reader: jspb.BinaryReader): Proposal;
   523  }
   524  
   525  export namespace Proposal {
   526      export type AsObject = {
   527          name: string,
   528          description: string,
   529          batchtx?: BatchTx.AsObject,
   530      }
   531  }
   532  
   533  export class Ballot extends jspb.Message { 
   534  
   535      hasProposal(): boolean;
   536      clearProposal(): void;
   537      getProposal(): Proposal | undefined;
   538      setProposal(value?: Proposal): Ballot;
   539      getFinalizingtx(): Uint8Array | string;
   540      getFinalizingtx_asU8(): Uint8Array;
   541      getFinalizingtx_asB64(): string;
   542      setFinalizingtx(value: Uint8Array | string): Ballot;
   543      getProposalstate(): Ballot.ProposalState;
   544      setProposalstate(value: Ballot.ProposalState): Ballot;
   545      clearVotesList(): void;
   546      getVotesList(): Array<Vote>;
   547      setVotesList(value: Array<Vote>): Ballot;
   548      addVotes(value?: Vote, index?: number): Vote;
   549  
   550      serializeBinary(): Uint8Array;
   551      toObject(includeInstance?: boolean): Ballot.AsObject;
   552      static toObject(includeInstance: boolean, msg: Ballot): Ballot.AsObject;
   553      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   554      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   555      static serializeBinaryToWriter(message: Ballot, writer: jspb.BinaryWriter): void;
   556      static deserializeBinary(bytes: Uint8Array): Ballot;
   557      static deserializeBinaryFromReader(message: Ballot, reader: jspb.BinaryReader): Ballot;
   558  }
   559  
   560  export namespace Ballot {
   561      export type AsObject = {
   562          proposal?: Proposal.AsObject,
   563          finalizingtx: Uint8Array | string,
   564          proposalstate: Ballot.ProposalState,
   565          votesList: Array<Vote.AsObject>,
   566      }
   567  
   568      export enum ProposalState {
   569      PROPOSED = 0,
   570      EXECUTED = 1,
   571      FAILED = 2,
   572      }
   573  
   574  }