@dashevo/dapi-grpc 4.2.0-dev.9 → 5.0.0-beta.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -647,6 +647,183 @@ export namespace GetIdentityContractNonceResponse {
647
647
  }
648
648
  }
649
649
 
650
+ export class GetIdentityKeysRemainingBudgetsRequest extends jspb.Message {
651
+ hasV0(): boolean;
652
+ clearV0(): void;
653
+ getV0(): GetIdentityKeysRemainingBudgetsRequest.GetIdentityKeysRemainingBudgetsRequestV0 | undefined;
654
+ setV0(value?: GetIdentityKeysRemainingBudgetsRequest.GetIdentityKeysRemainingBudgetsRequestV0): void;
655
+
656
+ getVersionCase(): GetIdentityKeysRemainingBudgetsRequest.VersionCase;
657
+ serializeBinary(): Uint8Array;
658
+ toObject(includeInstance?: boolean): GetIdentityKeysRemainingBudgetsRequest.AsObject;
659
+ static toObject(includeInstance: boolean, msg: GetIdentityKeysRemainingBudgetsRequest): GetIdentityKeysRemainingBudgetsRequest.AsObject;
660
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
661
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
662
+ static serializeBinaryToWriter(message: GetIdentityKeysRemainingBudgetsRequest, writer: jspb.BinaryWriter): void;
663
+ static deserializeBinary(bytes: Uint8Array): GetIdentityKeysRemainingBudgetsRequest;
664
+ static deserializeBinaryFromReader(message: GetIdentityKeysRemainingBudgetsRequest, reader: jspb.BinaryReader): GetIdentityKeysRemainingBudgetsRequest;
665
+ }
666
+
667
+ export namespace GetIdentityKeysRemainingBudgetsRequest {
668
+ export type AsObject = {
669
+ v0?: GetIdentityKeysRemainingBudgetsRequest.GetIdentityKeysRemainingBudgetsRequestV0.AsObject,
670
+ }
671
+
672
+ export class GetIdentityKeysRemainingBudgetsRequestV0 extends jspb.Message {
673
+ getIdentityId(): Uint8Array | string;
674
+ getIdentityId_asU8(): Uint8Array;
675
+ getIdentityId_asB64(): string;
676
+ setIdentityId(value: Uint8Array | string): void;
677
+
678
+ clearKeyIdsList(): void;
679
+ getKeyIdsList(): Array<number>;
680
+ setKeyIdsList(value: Array<number>): void;
681
+ addKeyIds(value: number, index?: number): number;
682
+
683
+ getProve(): boolean;
684
+ setProve(value: boolean): void;
685
+
686
+ serializeBinary(): Uint8Array;
687
+ toObject(includeInstance?: boolean): GetIdentityKeysRemainingBudgetsRequestV0.AsObject;
688
+ static toObject(includeInstance: boolean, msg: GetIdentityKeysRemainingBudgetsRequestV0): GetIdentityKeysRemainingBudgetsRequestV0.AsObject;
689
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
690
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
691
+ static serializeBinaryToWriter(message: GetIdentityKeysRemainingBudgetsRequestV0, writer: jspb.BinaryWriter): void;
692
+ static deserializeBinary(bytes: Uint8Array): GetIdentityKeysRemainingBudgetsRequestV0;
693
+ static deserializeBinaryFromReader(message: GetIdentityKeysRemainingBudgetsRequestV0, reader: jspb.BinaryReader): GetIdentityKeysRemainingBudgetsRequestV0;
694
+ }
695
+
696
+ export namespace GetIdentityKeysRemainingBudgetsRequestV0 {
697
+ export type AsObject = {
698
+ identityId: Uint8Array | string,
699
+ keyIdsList: Array<number>,
700
+ prove: boolean,
701
+ }
702
+ }
703
+
704
+ export enum VersionCase {
705
+ VERSION_NOT_SET = 0,
706
+ V0 = 1,
707
+ }
708
+ }
709
+
710
+ export class GetIdentityKeysRemainingBudgetsResponse extends jspb.Message {
711
+ hasV0(): boolean;
712
+ clearV0(): void;
713
+ getV0(): GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0 | undefined;
714
+ setV0(value?: GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0): void;
715
+
716
+ getVersionCase(): GetIdentityKeysRemainingBudgetsResponse.VersionCase;
717
+ serializeBinary(): Uint8Array;
718
+ toObject(includeInstance?: boolean): GetIdentityKeysRemainingBudgetsResponse.AsObject;
719
+ static toObject(includeInstance: boolean, msg: GetIdentityKeysRemainingBudgetsResponse): GetIdentityKeysRemainingBudgetsResponse.AsObject;
720
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
721
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
722
+ static serializeBinaryToWriter(message: GetIdentityKeysRemainingBudgetsResponse, writer: jspb.BinaryWriter): void;
723
+ static deserializeBinary(bytes: Uint8Array): GetIdentityKeysRemainingBudgetsResponse;
724
+ static deserializeBinaryFromReader(message: GetIdentityKeysRemainingBudgetsResponse, reader: jspb.BinaryReader): GetIdentityKeysRemainingBudgetsResponse;
725
+ }
726
+
727
+ export namespace GetIdentityKeysRemainingBudgetsResponse {
728
+ export type AsObject = {
729
+ v0?: GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0.AsObject,
730
+ }
731
+
732
+ export class GetIdentityKeysRemainingBudgetsResponseV0 extends jspb.Message {
733
+ hasKeysRemainingBudgets(): boolean;
734
+ clearKeysRemainingBudgets(): void;
735
+ getKeysRemainingBudgets(): GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0.KeysRemainingBudgets | undefined;
736
+ setKeysRemainingBudgets(value?: GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0.KeysRemainingBudgets): void;
737
+
738
+ hasProof(): boolean;
739
+ clearProof(): void;
740
+ getProof(): Proof | undefined;
741
+ setProof(value?: Proof): void;
742
+
743
+ hasMetadata(): boolean;
744
+ clearMetadata(): void;
745
+ getMetadata(): ResponseMetadata | undefined;
746
+ setMetadata(value?: ResponseMetadata): void;
747
+
748
+ getResultCase(): GetIdentityKeysRemainingBudgetsResponseV0.ResultCase;
749
+ serializeBinary(): Uint8Array;
750
+ toObject(includeInstance?: boolean): GetIdentityKeysRemainingBudgetsResponseV0.AsObject;
751
+ static toObject(includeInstance: boolean, msg: GetIdentityKeysRemainingBudgetsResponseV0): GetIdentityKeysRemainingBudgetsResponseV0.AsObject;
752
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
753
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
754
+ static serializeBinaryToWriter(message: GetIdentityKeysRemainingBudgetsResponseV0, writer: jspb.BinaryWriter): void;
755
+ static deserializeBinary(bytes: Uint8Array): GetIdentityKeysRemainingBudgetsResponseV0;
756
+ static deserializeBinaryFromReader(message: GetIdentityKeysRemainingBudgetsResponseV0, reader: jspb.BinaryReader): GetIdentityKeysRemainingBudgetsResponseV0;
757
+ }
758
+
759
+ export namespace GetIdentityKeysRemainingBudgetsResponseV0 {
760
+ export type AsObject = {
761
+ keysRemainingBudgets?: GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0.KeysRemainingBudgets.AsObject,
762
+ proof?: Proof.AsObject,
763
+ metadata?: ResponseMetadata.AsObject,
764
+ }
765
+
766
+ export class KeyRemainingBudgetEntry extends jspb.Message {
767
+ getKeyId(): number;
768
+ setKeyId(value: number): void;
769
+
770
+ hasRemainingBudget(): boolean;
771
+ clearRemainingBudget(): void;
772
+ getRemainingBudget(): string;
773
+ setRemainingBudget(value: string): void;
774
+
775
+ serializeBinary(): Uint8Array;
776
+ toObject(includeInstance?: boolean): KeyRemainingBudgetEntry.AsObject;
777
+ static toObject(includeInstance: boolean, msg: KeyRemainingBudgetEntry): KeyRemainingBudgetEntry.AsObject;
778
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
779
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
780
+ static serializeBinaryToWriter(message: KeyRemainingBudgetEntry, writer: jspb.BinaryWriter): void;
781
+ static deserializeBinary(bytes: Uint8Array): KeyRemainingBudgetEntry;
782
+ static deserializeBinaryFromReader(message: KeyRemainingBudgetEntry, reader: jspb.BinaryReader): KeyRemainingBudgetEntry;
783
+ }
784
+
785
+ export namespace KeyRemainingBudgetEntry {
786
+ export type AsObject = {
787
+ keyId: number,
788
+ remainingBudget: string,
789
+ }
790
+ }
791
+
792
+ export class KeysRemainingBudgets extends jspb.Message {
793
+ clearEntriesList(): void;
794
+ getEntriesList(): Array<GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0.KeyRemainingBudgetEntry>;
795
+ setEntriesList(value: Array<GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0.KeyRemainingBudgetEntry>): void;
796
+ addEntries(value?: GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0.KeyRemainingBudgetEntry, index?: number): GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0.KeyRemainingBudgetEntry;
797
+
798
+ serializeBinary(): Uint8Array;
799
+ toObject(includeInstance?: boolean): KeysRemainingBudgets.AsObject;
800
+ static toObject(includeInstance: boolean, msg: KeysRemainingBudgets): KeysRemainingBudgets.AsObject;
801
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
802
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
803
+ static serializeBinaryToWriter(message: KeysRemainingBudgets, writer: jspb.BinaryWriter): void;
804
+ static deserializeBinary(bytes: Uint8Array): KeysRemainingBudgets;
805
+ static deserializeBinaryFromReader(message: KeysRemainingBudgets, reader: jspb.BinaryReader): KeysRemainingBudgets;
806
+ }
807
+
808
+ export namespace KeysRemainingBudgets {
809
+ export type AsObject = {
810
+ entriesList: Array<GetIdentityKeysRemainingBudgetsResponse.GetIdentityKeysRemainingBudgetsResponseV0.KeyRemainingBudgetEntry.AsObject>,
811
+ }
812
+ }
813
+
814
+ export enum ResultCase {
815
+ RESULT_NOT_SET = 0,
816
+ KEYS_REMAINING_BUDGETS = 1,
817
+ PROOF = 2,
818
+ }
819
+ }
820
+
821
+ export enum VersionCase {
822
+ VERSION_NOT_SET = 0,
823
+ V0 = 1,
824
+ }
825
+ }
826
+
650
827
  export class GetIdentityBalanceResponse extends jspb.Message {
651
828
  hasV0(): boolean;
652
829
  clearV0(): void;
@@ -1785,61 +1962,2603 @@ export namespace GetDataContractRequest {
1785
1962
  getId_asB64(): string;
1786
1963
  setId(value: Uint8Array | string): void;
1787
1964
 
1788
- getProve(): boolean;
1789
- setProve(value: boolean): void;
1965
+ getProve(): boolean;
1966
+ setProve(value: boolean): void;
1967
+
1968
+ serializeBinary(): Uint8Array;
1969
+ toObject(includeInstance?: boolean): GetDataContractRequestV0.AsObject;
1970
+ static toObject(includeInstance: boolean, msg: GetDataContractRequestV0): GetDataContractRequestV0.AsObject;
1971
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
1972
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
1973
+ static serializeBinaryToWriter(message: GetDataContractRequestV0, writer: jspb.BinaryWriter): void;
1974
+ static deserializeBinary(bytes: Uint8Array): GetDataContractRequestV0;
1975
+ static deserializeBinaryFromReader(message: GetDataContractRequestV0, reader: jspb.BinaryReader): GetDataContractRequestV0;
1976
+ }
1977
+
1978
+ export namespace GetDataContractRequestV0 {
1979
+ export type AsObject = {
1980
+ id: Uint8Array | string,
1981
+ prove: boolean,
1982
+ }
1983
+ }
1984
+
1985
+ export enum VersionCase {
1986
+ VERSION_NOT_SET = 0,
1987
+ V0 = 1,
1988
+ }
1989
+ }
1990
+
1991
+ export class GetDataContractResponse extends jspb.Message {
1992
+ hasV0(): boolean;
1993
+ clearV0(): void;
1994
+ getV0(): GetDataContractResponse.GetDataContractResponseV0 | undefined;
1995
+ setV0(value?: GetDataContractResponse.GetDataContractResponseV0): void;
1996
+
1997
+ getVersionCase(): GetDataContractResponse.VersionCase;
1998
+ serializeBinary(): Uint8Array;
1999
+ toObject(includeInstance?: boolean): GetDataContractResponse.AsObject;
2000
+ static toObject(includeInstance: boolean, msg: GetDataContractResponse): GetDataContractResponse.AsObject;
2001
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2002
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2003
+ static serializeBinaryToWriter(message: GetDataContractResponse, writer: jspb.BinaryWriter): void;
2004
+ static deserializeBinary(bytes: Uint8Array): GetDataContractResponse;
2005
+ static deserializeBinaryFromReader(message: GetDataContractResponse, reader: jspb.BinaryReader): GetDataContractResponse;
2006
+ }
2007
+
2008
+ export namespace GetDataContractResponse {
2009
+ export type AsObject = {
2010
+ v0?: GetDataContractResponse.GetDataContractResponseV0.AsObject,
2011
+ }
2012
+
2013
+ export class GetDataContractResponseV0 extends jspb.Message {
2014
+ hasDataContract(): boolean;
2015
+ clearDataContract(): void;
2016
+ getDataContract(): Uint8Array | string;
2017
+ getDataContract_asU8(): Uint8Array;
2018
+ getDataContract_asB64(): string;
2019
+ setDataContract(value: Uint8Array | string): void;
2020
+
2021
+ hasProof(): boolean;
2022
+ clearProof(): void;
2023
+ getProof(): Proof | undefined;
2024
+ setProof(value?: Proof): void;
2025
+
2026
+ hasMetadata(): boolean;
2027
+ clearMetadata(): void;
2028
+ getMetadata(): ResponseMetadata | undefined;
2029
+ setMetadata(value?: ResponseMetadata): void;
2030
+
2031
+ getResultCase(): GetDataContractResponseV0.ResultCase;
2032
+ serializeBinary(): Uint8Array;
2033
+ toObject(includeInstance?: boolean): GetDataContractResponseV0.AsObject;
2034
+ static toObject(includeInstance: boolean, msg: GetDataContractResponseV0): GetDataContractResponseV0.AsObject;
2035
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2036
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2037
+ static serializeBinaryToWriter(message: GetDataContractResponseV0, writer: jspb.BinaryWriter): void;
2038
+ static deserializeBinary(bytes: Uint8Array): GetDataContractResponseV0;
2039
+ static deserializeBinaryFromReader(message: GetDataContractResponseV0, reader: jspb.BinaryReader): GetDataContractResponseV0;
2040
+ }
2041
+
2042
+ export namespace GetDataContractResponseV0 {
2043
+ export type AsObject = {
2044
+ dataContract: Uint8Array | string,
2045
+ proof?: Proof.AsObject,
2046
+ metadata?: ResponseMetadata.AsObject,
2047
+ }
2048
+
2049
+ export enum ResultCase {
2050
+ RESULT_NOT_SET = 0,
2051
+ DATA_CONTRACT = 1,
2052
+ PROOF = 2,
2053
+ }
2054
+ }
2055
+
2056
+ export enum VersionCase {
2057
+ VERSION_NOT_SET = 0,
2058
+ V0 = 1,
2059
+ }
2060
+ }
2061
+
2062
+ export class GetDataContractsLatestVersionsRequest extends jspb.Message {
2063
+ hasV0(): boolean;
2064
+ clearV0(): void;
2065
+ getV0(): GetDataContractsLatestVersionsRequest.GetDataContractsLatestVersionsRequestV0 | undefined;
2066
+ setV0(value?: GetDataContractsLatestVersionsRequest.GetDataContractsLatestVersionsRequestV0): void;
2067
+
2068
+ getVersionCase(): GetDataContractsLatestVersionsRequest.VersionCase;
2069
+ serializeBinary(): Uint8Array;
2070
+ toObject(includeInstance?: boolean): GetDataContractsLatestVersionsRequest.AsObject;
2071
+ static toObject(includeInstance: boolean, msg: GetDataContractsLatestVersionsRequest): GetDataContractsLatestVersionsRequest.AsObject;
2072
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2073
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2074
+ static serializeBinaryToWriter(message: GetDataContractsLatestVersionsRequest, writer: jspb.BinaryWriter): void;
2075
+ static deserializeBinary(bytes: Uint8Array): GetDataContractsLatestVersionsRequest;
2076
+ static deserializeBinaryFromReader(message: GetDataContractsLatestVersionsRequest, reader: jspb.BinaryReader): GetDataContractsLatestVersionsRequest;
2077
+ }
2078
+
2079
+ export namespace GetDataContractsLatestVersionsRequest {
2080
+ export type AsObject = {
2081
+ v0?: GetDataContractsLatestVersionsRequest.GetDataContractsLatestVersionsRequestV0.AsObject,
2082
+ }
2083
+
2084
+ export class GetDataContractsLatestVersionsRequestV0 extends jspb.Message {
2085
+ clearIdsList(): void;
2086
+ getIdsList(): Array<Uint8Array | string>;
2087
+ getIdsList_asU8(): Array<Uint8Array>;
2088
+ getIdsList_asB64(): Array<string>;
2089
+ setIdsList(value: Array<Uint8Array | string>): void;
2090
+ addIds(value: Uint8Array | string, index?: number): Uint8Array | string;
2091
+
2092
+ getIncludeContracts(): boolean;
2093
+ setIncludeContracts(value: boolean): void;
2094
+
2095
+ getProve(): boolean;
2096
+ setProve(value: boolean): void;
2097
+
2098
+ serializeBinary(): Uint8Array;
2099
+ toObject(includeInstance?: boolean): GetDataContractsLatestVersionsRequestV0.AsObject;
2100
+ static toObject(includeInstance: boolean, msg: GetDataContractsLatestVersionsRequestV0): GetDataContractsLatestVersionsRequestV0.AsObject;
2101
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2102
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2103
+ static serializeBinaryToWriter(message: GetDataContractsLatestVersionsRequestV0, writer: jspb.BinaryWriter): void;
2104
+ static deserializeBinary(bytes: Uint8Array): GetDataContractsLatestVersionsRequestV0;
2105
+ static deserializeBinaryFromReader(message: GetDataContractsLatestVersionsRequestV0, reader: jspb.BinaryReader): GetDataContractsLatestVersionsRequestV0;
2106
+ }
2107
+
2108
+ export namespace GetDataContractsLatestVersionsRequestV0 {
2109
+ export type AsObject = {
2110
+ idsList: Array<Uint8Array | string>,
2111
+ includeContracts: boolean,
2112
+ prove: boolean,
2113
+ }
2114
+ }
2115
+
2116
+ export enum VersionCase {
2117
+ VERSION_NOT_SET = 0,
2118
+ V0 = 1,
2119
+ }
2120
+ }
2121
+
2122
+ export class GetDataContractsLatestVersionsResponse extends jspb.Message {
2123
+ hasV0(): boolean;
2124
+ clearV0(): void;
2125
+ getV0(): GetDataContractsLatestVersionsResponse.GetDataContractsLatestVersionsResponseV0 | undefined;
2126
+ setV0(value?: GetDataContractsLatestVersionsResponse.GetDataContractsLatestVersionsResponseV0): void;
2127
+
2128
+ getVersionCase(): GetDataContractsLatestVersionsResponse.VersionCase;
2129
+ serializeBinary(): Uint8Array;
2130
+ toObject(includeInstance?: boolean): GetDataContractsLatestVersionsResponse.AsObject;
2131
+ static toObject(includeInstance: boolean, msg: GetDataContractsLatestVersionsResponse): GetDataContractsLatestVersionsResponse.AsObject;
2132
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2133
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2134
+ static serializeBinaryToWriter(message: GetDataContractsLatestVersionsResponse, writer: jspb.BinaryWriter): void;
2135
+ static deserializeBinary(bytes: Uint8Array): GetDataContractsLatestVersionsResponse;
2136
+ static deserializeBinaryFromReader(message: GetDataContractsLatestVersionsResponse, reader: jspb.BinaryReader): GetDataContractsLatestVersionsResponse;
2137
+ }
2138
+
2139
+ export namespace GetDataContractsLatestVersionsResponse {
2140
+ export type AsObject = {
2141
+ v0?: GetDataContractsLatestVersionsResponse.GetDataContractsLatestVersionsResponseV0.AsObject,
2142
+ }
2143
+
2144
+ export class DataContractLatestVersionEntry extends jspb.Message {
2145
+ getIdentifier(): Uint8Array | string;
2146
+ getIdentifier_asU8(): Uint8Array;
2147
+ getIdentifier_asB64(): string;
2148
+ setIdentifier(value: Uint8Array | string): void;
2149
+
2150
+ hasVersion(): boolean;
2151
+ clearVersion(): void;
2152
+ getVersion(): number;
2153
+ setVersion(value: number): void;
2154
+
2155
+ hasDataContract(): boolean;
2156
+ clearDataContract(): void;
2157
+ getDataContract(): Uint8Array | string;
2158
+ getDataContract_asU8(): Uint8Array;
2159
+ getDataContract_asB64(): string;
2160
+ setDataContract(value: Uint8Array | string): void;
2161
+
2162
+ serializeBinary(): Uint8Array;
2163
+ toObject(includeInstance?: boolean): DataContractLatestVersionEntry.AsObject;
2164
+ static toObject(includeInstance: boolean, msg: DataContractLatestVersionEntry): DataContractLatestVersionEntry.AsObject;
2165
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2166
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2167
+ static serializeBinaryToWriter(message: DataContractLatestVersionEntry, writer: jspb.BinaryWriter): void;
2168
+ static deserializeBinary(bytes: Uint8Array): DataContractLatestVersionEntry;
2169
+ static deserializeBinaryFromReader(message: DataContractLatestVersionEntry, reader: jspb.BinaryReader): DataContractLatestVersionEntry;
2170
+ }
2171
+
2172
+ export namespace DataContractLatestVersionEntry {
2173
+ export type AsObject = {
2174
+ identifier: Uint8Array | string,
2175
+ version: number,
2176
+ dataContract: Uint8Array | string,
2177
+ }
2178
+ }
2179
+
2180
+ export class DataContractsLatestVersions extends jspb.Message {
2181
+ clearEntriesList(): void;
2182
+ getEntriesList(): Array<GetDataContractsLatestVersionsResponse.DataContractLatestVersionEntry>;
2183
+ setEntriesList(value: Array<GetDataContractsLatestVersionsResponse.DataContractLatestVersionEntry>): void;
2184
+ addEntries(value?: GetDataContractsLatestVersionsResponse.DataContractLatestVersionEntry, index?: number): GetDataContractsLatestVersionsResponse.DataContractLatestVersionEntry;
2185
+
2186
+ serializeBinary(): Uint8Array;
2187
+ toObject(includeInstance?: boolean): DataContractsLatestVersions.AsObject;
2188
+ static toObject(includeInstance: boolean, msg: DataContractsLatestVersions): DataContractsLatestVersions.AsObject;
2189
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2190
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2191
+ static serializeBinaryToWriter(message: DataContractsLatestVersions, writer: jspb.BinaryWriter): void;
2192
+ static deserializeBinary(bytes: Uint8Array): DataContractsLatestVersions;
2193
+ static deserializeBinaryFromReader(message: DataContractsLatestVersions, reader: jspb.BinaryReader): DataContractsLatestVersions;
2194
+ }
2195
+
2196
+ export namespace DataContractsLatestVersions {
2197
+ export type AsObject = {
2198
+ entriesList: Array<GetDataContractsLatestVersionsResponse.DataContractLatestVersionEntry.AsObject>,
2199
+ }
2200
+ }
2201
+
2202
+ export class GetDataContractsLatestVersionsResponseV0 extends jspb.Message {
2203
+ hasDataContractsLatestVersions(): boolean;
2204
+ clearDataContractsLatestVersions(): void;
2205
+ getDataContractsLatestVersions(): GetDataContractsLatestVersionsResponse.DataContractsLatestVersions | undefined;
2206
+ setDataContractsLatestVersions(value?: GetDataContractsLatestVersionsResponse.DataContractsLatestVersions): void;
2207
+
2208
+ hasProof(): boolean;
2209
+ clearProof(): void;
2210
+ getProof(): Proof | undefined;
2211
+ setProof(value?: Proof): void;
2212
+
2213
+ hasMetadata(): boolean;
2214
+ clearMetadata(): void;
2215
+ getMetadata(): ResponseMetadata | undefined;
2216
+ setMetadata(value?: ResponseMetadata): void;
2217
+
2218
+ getResultCase(): GetDataContractsLatestVersionsResponseV0.ResultCase;
2219
+ serializeBinary(): Uint8Array;
2220
+ toObject(includeInstance?: boolean): GetDataContractsLatestVersionsResponseV0.AsObject;
2221
+ static toObject(includeInstance: boolean, msg: GetDataContractsLatestVersionsResponseV0): GetDataContractsLatestVersionsResponseV0.AsObject;
2222
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2223
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2224
+ static serializeBinaryToWriter(message: GetDataContractsLatestVersionsResponseV0, writer: jspb.BinaryWriter): void;
2225
+ static deserializeBinary(bytes: Uint8Array): GetDataContractsLatestVersionsResponseV0;
2226
+ static deserializeBinaryFromReader(message: GetDataContractsLatestVersionsResponseV0, reader: jspb.BinaryReader): GetDataContractsLatestVersionsResponseV0;
2227
+ }
2228
+
2229
+ export namespace GetDataContractsLatestVersionsResponseV0 {
2230
+ export type AsObject = {
2231
+ dataContractsLatestVersions?: GetDataContractsLatestVersionsResponse.DataContractsLatestVersions.AsObject,
2232
+ proof?: Proof.AsObject,
2233
+ metadata?: ResponseMetadata.AsObject,
2234
+ }
2235
+
2236
+ export enum ResultCase {
2237
+ RESULT_NOT_SET = 0,
2238
+ DATA_CONTRACTS_LATEST_VERSIONS = 1,
2239
+ PROOF = 2,
2240
+ }
2241
+ }
2242
+
2243
+ export enum VersionCase {
2244
+ VERSION_NOT_SET = 0,
2245
+ V0 = 1,
2246
+ }
2247
+ }
2248
+
2249
+ export class ContractGroupDocumentTypeMember extends jspb.Message {
2250
+ getContractId(): Uint8Array | string;
2251
+ getContractId_asU8(): Uint8Array;
2252
+ getContractId_asB64(): string;
2253
+ setContractId(value: Uint8Array | string): void;
2254
+
2255
+ getDocumentTypeName(): string;
2256
+ setDocumentTypeName(value: string): void;
2257
+
2258
+ serializeBinary(): Uint8Array;
2259
+ toObject(includeInstance?: boolean): ContractGroupDocumentTypeMember.AsObject;
2260
+ static toObject(includeInstance: boolean, msg: ContractGroupDocumentTypeMember): ContractGroupDocumentTypeMember.AsObject;
2261
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2262
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2263
+ static serializeBinaryToWriter(message: ContractGroupDocumentTypeMember, writer: jspb.BinaryWriter): void;
2264
+ static deserializeBinary(bytes: Uint8Array): ContractGroupDocumentTypeMember;
2265
+ static deserializeBinaryFromReader(message: ContractGroupDocumentTypeMember, reader: jspb.BinaryReader): ContractGroupDocumentTypeMember;
2266
+ }
2267
+
2268
+ export namespace ContractGroupDocumentTypeMember {
2269
+ export type AsObject = {
2270
+ contractId: Uint8Array | string,
2271
+ documentTypeName: string,
2272
+ }
2273
+ }
2274
+
2275
+ export class ContractGroupTokenMember extends jspb.Message {
2276
+ getContractId(): Uint8Array | string;
2277
+ getContractId_asU8(): Uint8Array;
2278
+ getContractId_asB64(): string;
2279
+ setContractId(value: Uint8Array | string): void;
2280
+
2281
+ getTokenPosition(): number;
2282
+ setTokenPosition(value: number): void;
2283
+
2284
+ serializeBinary(): Uint8Array;
2285
+ toObject(includeInstance?: boolean): ContractGroupTokenMember.AsObject;
2286
+ static toObject(includeInstance: boolean, msg: ContractGroupTokenMember): ContractGroupTokenMember.AsObject;
2287
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2288
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2289
+ static serializeBinaryToWriter(message: ContractGroupTokenMember, writer: jspb.BinaryWriter): void;
2290
+ static deserializeBinary(bytes: Uint8Array): ContractGroupTokenMember;
2291
+ static deserializeBinaryFromReader(message: ContractGroupTokenMember, reader: jspb.BinaryReader): ContractGroupTokenMember;
2292
+ }
2293
+
2294
+ export namespace ContractGroupTokenMember {
2295
+ export type AsObject = {
2296
+ contractId: Uint8Array | string,
2297
+ tokenPosition: number,
2298
+ }
2299
+ }
2300
+
2301
+ export class GetContractGroupInfoRequest extends jspb.Message {
2302
+ hasV0(): boolean;
2303
+ clearV0(): void;
2304
+ getV0(): GetContractGroupInfoRequest.GetContractGroupInfoRequestV0 | undefined;
2305
+ setV0(value?: GetContractGroupInfoRequest.GetContractGroupInfoRequestV0): void;
2306
+
2307
+ getVersionCase(): GetContractGroupInfoRequest.VersionCase;
2308
+ serializeBinary(): Uint8Array;
2309
+ toObject(includeInstance?: boolean): GetContractGroupInfoRequest.AsObject;
2310
+ static toObject(includeInstance: boolean, msg: GetContractGroupInfoRequest): GetContractGroupInfoRequest.AsObject;
2311
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2312
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2313
+ static serializeBinaryToWriter(message: GetContractGroupInfoRequest, writer: jspb.BinaryWriter): void;
2314
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupInfoRequest;
2315
+ static deserializeBinaryFromReader(message: GetContractGroupInfoRequest, reader: jspb.BinaryReader): GetContractGroupInfoRequest;
2316
+ }
2317
+
2318
+ export namespace GetContractGroupInfoRequest {
2319
+ export type AsObject = {
2320
+ v0?: GetContractGroupInfoRequest.GetContractGroupInfoRequestV0.AsObject,
2321
+ }
2322
+
2323
+ export class GetContractGroupInfoRequestV0 extends jspb.Message {
2324
+ getContractGroupId(): Uint8Array | string;
2325
+ getContractGroupId_asU8(): Uint8Array;
2326
+ getContractGroupId_asB64(): string;
2327
+ setContractGroupId(value: Uint8Array | string): void;
2328
+
2329
+ getProve(): boolean;
2330
+ setProve(value: boolean): void;
2331
+
2332
+ serializeBinary(): Uint8Array;
2333
+ toObject(includeInstance?: boolean): GetContractGroupInfoRequestV0.AsObject;
2334
+ static toObject(includeInstance: boolean, msg: GetContractGroupInfoRequestV0): GetContractGroupInfoRequestV0.AsObject;
2335
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2336
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2337
+ static serializeBinaryToWriter(message: GetContractGroupInfoRequestV0, writer: jspb.BinaryWriter): void;
2338
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupInfoRequestV0;
2339
+ static deserializeBinaryFromReader(message: GetContractGroupInfoRequestV0, reader: jspb.BinaryReader): GetContractGroupInfoRequestV0;
2340
+ }
2341
+
2342
+ export namespace GetContractGroupInfoRequestV0 {
2343
+ export type AsObject = {
2344
+ contractGroupId: Uint8Array | string,
2345
+ prove: boolean,
2346
+ }
2347
+ }
2348
+
2349
+ export enum VersionCase {
2350
+ VERSION_NOT_SET = 0,
2351
+ V0 = 1,
2352
+ }
2353
+ }
2354
+
2355
+ export class GetContractGroupInfoResponse extends jspb.Message {
2356
+ hasV0(): boolean;
2357
+ clearV0(): void;
2358
+ getV0(): GetContractGroupInfoResponse.GetContractGroupInfoResponseV0 | undefined;
2359
+ setV0(value?: GetContractGroupInfoResponse.GetContractGroupInfoResponseV0): void;
2360
+
2361
+ getVersionCase(): GetContractGroupInfoResponse.VersionCase;
2362
+ serializeBinary(): Uint8Array;
2363
+ toObject(includeInstance?: boolean): GetContractGroupInfoResponse.AsObject;
2364
+ static toObject(includeInstance: boolean, msg: GetContractGroupInfoResponse): GetContractGroupInfoResponse.AsObject;
2365
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2366
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2367
+ static serializeBinaryToWriter(message: GetContractGroupInfoResponse, writer: jspb.BinaryWriter): void;
2368
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupInfoResponse;
2369
+ static deserializeBinaryFromReader(message: GetContractGroupInfoResponse, reader: jspb.BinaryReader): GetContractGroupInfoResponse;
2370
+ }
2371
+
2372
+ export namespace GetContractGroupInfoResponse {
2373
+ export type AsObject = {
2374
+ v0?: GetContractGroupInfoResponse.GetContractGroupInfoResponseV0.AsObject,
2375
+ }
2376
+
2377
+ export class ContractGroupInfo extends jspb.Message {
2378
+ getOwnerId(): Uint8Array | string;
2379
+ getOwnerId_asU8(): Uint8Array;
2380
+ getOwnerId_asB64(): string;
2381
+ setOwnerId(value: Uint8Array | string): void;
2382
+
2383
+ clearAdminIdsList(): void;
2384
+ getAdminIdsList(): Array<Uint8Array | string>;
2385
+ getAdminIdsList_asU8(): Array<Uint8Array>;
2386
+ getAdminIdsList_asB64(): Array<string>;
2387
+ setAdminIdsList(value: Array<Uint8Array | string>): void;
2388
+ addAdminIds(value: Uint8Array | string, index?: number): Uint8Array | string;
2389
+
2390
+ hasName(): boolean;
2391
+ clearName(): void;
2392
+ getName(): string;
2393
+ setName(value: string): void;
2394
+
2395
+ hasDescription(): boolean;
2396
+ clearDescription(): void;
2397
+ getDescription(): string;
2398
+ setDescription(value: string): void;
2399
+
2400
+ serializeBinary(): Uint8Array;
2401
+ toObject(includeInstance?: boolean): ContractGroupInfo.AsObject;
2402
+ static toObject(includeInstance: boolean, msg: ContractGroupInfo): ContractGroupInfo.AsObject;
2403
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2404
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2405
+ static serializeBinaryToWriter(message: ContractGroupInfo, writer: jspb.BinaryWriter): void;
2406
+ static deserializeBinary(bytes: Uint8Array): ContractGroupInfo;
2407
+ static deserializeBinaryFromReader(message: ContractGroupInfo, reader: jspb.BinaryReader): ContractGroupInfo;
2408
+ }
2409
+
2410
+ export namespace ContractGroupInfo {
2411
+ export type AsObject = {
2412
+ ownerId: Uint8Array | string,
2413
+ adminIdsList: Array<Uint8Array | string>,
2414
+ name: string,
2415
+ description: string,
2416
+ }
2417
+ }
2418
+
2419
+ export class GetContractGroupInfoResponseV0 extends jspb.Message {
2420
+ hasContractGroupInfo(): boolean;
2421
+ clearContractGroupInfo(): void;
2422
+ getContractGroupInfo(): GetContractGroupInfoResponse.ContractGroupInfo | undefined;
2423
+ setContractGroupInfo(value?: GetContractGroupInfoResponse.ContractGroupInfo): void;
2424
+
2425
+ hasProof(): boolean;
2426
+ clearProof(): void;
2427
+ getProof(): Proof | undefined;
2428
+ setProof(value?: Proof): void;
2429
+
2430
+ hasMetadata(): boolean;
2431
+ clearMetadata(): void;
2432
+ getMetadata(): ResponseMetadata | undefined;
2433
+ setMetadata(value?: ResponseMetadata): void;
2434
+
2435
+ getResultCase(): GetContractGroupInfoResponseV0.ResultCase;
2436
+ serializeBinary(): Uint8Array;
2437
+ toObject(includeInstance?: boolean): GetContractGroupInfoResponseV0.AsObject;
2438
+ static toObject(includeInstance: boolean, msg: GetContractGroupInfoResponseV0): GetContractGroupInfoResponseV0.AsObject;
2439
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2440
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2441
+ static serializeBinaryToWriter(message: GetContractGroupInfoResponseV0, writer: jspb.BinaryWriter): void;
2442
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupInfoResponseV0;
2443
+ static deserializeBinaryFromReader(message: GetContractGroupInfoResponseV0, reader: jspb.BinaryReader): GetContractGroupInfoResponseV0;
2444
+ }
2445
+
2446
+ export namespace GetContractGroupInfoResponseV0 {
2447
+ export type AsObject = {
2448
+ contractGroupInfo?: GetContractGroupInfoResponse.ContractGroupInfo.AsObject,
2449
+ proof?: Proof.AsObject,
2450
+ metadata?: ResponseMetadata.AsObject,
2451
+ }
2452
+
2453
+ export enum ResultCase {
2454
+ RESULT_NOT_SET = 0,
2455
+ CONTRACT_GROUP_INFO = 1,
2456
+ PROOF = 2,
2457
+ }
2458
+ }
2459
+
2460
+ export enum VersionCase {
2461
+ VERSION_NOT_SET = 0,
2462
+ V0 = 1,
2463
+ }
2464
+ }
2465
+
2466
+ export class GetContractGroupMembersRequest extends jspb.Message {
2467
+ hasV0(): boolean;
2468
+ clearV0(): void;
2469
+ getV0(): GetContractGroupMembersRequest.GetContractGroupMembersRequestV0 | undefined;
2470
+ setV0(value?: GetContractGroupMembersRequest.GetContractGroupMembersRequestV0): void;
2471
+
2472
+ getVersionCase(): GetContractGroupMembersRequest.VersionCase;
2473
+ serializeBinary(): Uint8Array;
2474
+ toObject(includeInstance?: boolean): GetContractGroupMembersRequest.AsObject;
2475
+ static toObject(includeInstance: boolean, msg: GetContractGroupMembersRequest): GetContractGroupMembersRequest.AsObject;
2476
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2477
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2478
+ static serializeBinaryToWriter(message: GetContractGroupMembersRequest, writer: jspb.BinaryWriter): void;
2479
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupMembersRequest;
2480
+ static deserializeBinaryFromReader(message: GetContractGroupMembersRequest, reader: jspb.BinaryReader): GetContractGroupMembersRequest;
2481
+ }
2482
+
2483
+ export namespace GetContractGroupMembersRequest {
2484
+ export type AsObject = {
2485
+ v0?: GetContractGroupMembersRequest.GetContractGroupMembersRequestV0.AsObject,
2486
+ }
2487
+
2488
+ export class ContractMembersQuery extends jspb.Message {
2489
+ hasStartAfter(): boolean;
2490
+ clearStartAfter(): void;
2491
+ getStartAfter(): Uint8Array | string;
2492
+ getStartAfter_asU8(): Uint8Array;
2493
+ getStartAfter_asB64(): string;
2494
+ setStartAfter(value: Uint8Array | string): void;
2495
+
2496
+ serializeBinary(): Uint8Array;
2497
+ toObject(includeInstance?: boolean): ContractMembersQuery.AsObject;
2498
+ static toObject(includeInstance: boolean, msg: ContractMembersQuery): ContractMembersQuery.AsObject;
2499
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2500
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2501
+ static serializeBinaryToWriter(message: ContractMembersQuery, writer: jspb.BinaryWriter): void;
2502
+ static deserializeBinary(bytes: Uint8Array): ContractMembersQuery;
2503
+ static deserializeBinaryFromReader(message: ContractMembersQuery, reader: jspb.BinaryReader): ContractMembersQuery;
2504
+ }
2505
+
2506
+ export namespace ContractMembersQuery {
2507
+ export type AsObject = {
2508
+ startAfter: Uint8Array | string,
2509
+ }
2510
+ }
2511
+
2512
+ export class DocumentTypeMembersQuery extends jspb.Message {
2513
+ hasStartAfter(): boolean;
2514
+ clearStartAfter(): void;
2515
+ getStartAfter(): ContractGroupDocumentTypeMember | undefined;
2516
+ setStartAfter(value?: ContractGroupDocumentTypeMember): void;
2517
+
2518
+ serializeBinary(): Uint8Array;
2519
+ toObject(includeInstance?: boolean): DocumentTypeMembersQuery.AsObject;
2520
+ static toObject(includeInstance: boolean, msg: DocumentTypeMembersQuery): DocumentTypeMembersQuery.AsObject;
2521
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2522
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2523
+ static serializeBinaryToWriter(message: DocumentTypeMembersQuery, writer: jspb.BinaryWriter): void;
2524
+ static deserializeBinary(bytes: Uint8Array): DocumentTypeMembersQuery;
2525
+ static deserializeBinaryFromReader(message: DocumentTypeMembersQuery, reader: jspb.BinaryReader): DocumentTypeMembersQuery;
2526
+ }
2527
+
2528
+ export namespace DocumentTypeMembersQuery {
2529
+ export type AsObject = {
2530
+ startAfter?: ContractGroupDocumentTypeMember.AsObject,
2531
+ }
2532
+ }
2533
+
2534
+ export class TokenMembersQuery extends jspb.Message {
2535
+ hasStartAfter(): boolean;
2536
+ clearStartAfter(): void;
2537
+ getStartAfter(): ContractGroupTokenMember | undefined;
2538
+ setStartAfter(value?: ContractGroupTokenMember): void;
2539
+
2540
+ serializeBinary(): Uint8Array;
2541
+ toObject(includeInstance?: boolean): TokenMembersQuery.AsObject;
2542
+ static toObject(includeInstance: boolean, msg: TokenMembersQuery): TokenMembersQuery.AsObject;
2543
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2544
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2545
+ static serializeBinaryToWriter(message: TokenMembersQuery, writer: jspb.BinaryWriter): void;
2546
+ static deserializeBinary(bytes: Uint8Array): TokenMembersQuery;
2547
+ static deserializeBinaryFromReader(message: TokenMembersQuery, reader: jspb.BinaryReader): TokenMembersQuery;
2548
+ }
2549
+
2550
+ export namespace TokenMembersQuery {
2551
+ export type AsObject = {
2552
+ startAfter?: ContractGroupTokenMember.AsObject,
2553
+ }
2554
+ }
2555
+
2556
+ export class GetContractGroupMembersRequestV0 extends jspb.Message {
2557
+ getContractGroupId(): Uint8Array | string;
2558
+ getContractGroupId_asU8(): Uint8Array;
2559
+ getContractGroupId_asB64(): string;
2560
+ setContractGroupId(value: Uint8Array | string): void;
2561
+
2562
+ hasContracts(): boolean;
2563
+ clearContracts(): void;
2564
+ getContracts(): GetContractGroupMembersRequest.ContractMembersQuery | undefined;
2565
+ setContracts(value?: GetContractGroupMembersRequest.ContractMembersQuery): void;
2566
+
2567
+ hasDocumentTypes(): boolean;
2568
+ clearDocumentTypes(): void;
2569
+ getDocumentTypes(): GetContractGroupMembersRequest.DocumentTypeMembersQuery | undefined;
2570
+ setDocumentTypes(value?: GetContractGroupMembersRequest.DocumentTypeMembersQuery): void;
2571
+
2572
+ hasTokens(): boolean;
2573
+ clearTokens(): void;
2574
+ getTokens(): GetContractGroupMembersRequest.TokenMembersQuery | undefined;
2575
+ setTokens(value?: GetContractGroupMembersRequest.TokenMembersQuery): void;
2576
+
2577
+ hasLimit(): boolean;
2578
+ clearLimit(): void;
2579
+ getLimit(): number;
2580
+ setLimit(value: number): void;
2581
+
2582
+ getProve(): boolean;
2583
+ setProve(value: boolean): void;
2584
+
2585
+ getMembersCase(): GetContractGroupMembersRequestV0.MembersCase;
2586
+ serializeBinary(): Uint8Array;
2587
+ toObject(includeInstance?: boolean): GetContractGroupMembersRequestV0.AsObject;
2588
+ static toObject(includeInstance: boolean, msg: GetContractGroupMembersRequestV0): GetContractGroupMembersRequestV0.AsObject;
2589
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2590
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2591
+ static serializeBinaryToWriter(message: GetContractGroupMembersRequestV0, writer: jspb.BinaryWriter): void;
2592
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupMembersRequestV0;
2593
+ static deserializeBinaryFromReader(message: GetContractGroupMembersRequestV0, reader: jspb.BinaryReader): GetContractGroupMembersRequestV0;
2594
+ }
2595
+
2596
+ export namespace GetContractGroupMembersRequestV0 {
2597
+ export type AsObject = {
2598
+ contractGroupId: Uint8Array | string,
2599
+ contracts?: GetContractGroupMembersRequest.ContractMembersQuery.AsObject,
2600
+ documentTypes?: GetContractGroupMembersRequest.DocumentTypeMembersQuery.AsObject,
2601
+ tokens?: GetContractGroupMembersRequest.TokenMembersQuery.AsObject,
2602
+ limit: number,
2603
+ prove: boolean,
2604
+ }
2605
+
2606
+ export enum MembersCase {
2607
+ MEMBERS_NOT_SET = 0,
2608
+ CONTRACTS = 2,
2609
+ DOCUMENT_TYPES = 3,
2610
+ TOKENS = 4,
2611
+ }
2612
+ }
2613
+
2614
+ export enum VersionCase {
2615
+ VERSION_NOT_SET = 0,
2616
+ V0 = 1,
2617
+ }
2618
+ }
2619
+
2620
+ export class GetContractGroupMembersResponse extends jspb.Message {
2621
+ hasV0(): boolean;
2622
+ clearV0(): void;
2623
+ getV0(): GetContractGroupMembersResponse.GetContractGroupMembersResponseV0 | undefined;
2624
+ setV0(value?: GetContractGroupMembersResponse.GetContractGroupMembersResponseV0): void;
2625
+
2626
+ getVersionCase(): GetContractGroupMembersResponse.VersionCase;
2627
+ serializeBinary(): Uint8Array;
2628
+ toObject(includeInstance?: boolean): GetContractGroupMembersResponse.AsObject;
2629
+ static toObject(includeInstance: boolean, msg: GetContractGroupMembersResponse): GetContractGroupMembersResponse.AsObject;
2630
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2631
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2632
+ static serializeBinaryToWriter(message: GetContractGroupMembersResponse, writer: jspb.BinaryWriter): void;
2633
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupMembersResponse;
2634
+ static deserializeBinaryFromReader(message: GetContractGroupMembersResponse, reader: jspb.BinaryReader): GetContractGroupMembersResponse;
2635
+ }
2636
+
2637
+ export namespace GetContractGroupMembersResponse {
2638
+ export type AsObject = {
2639
+ v0?: GetContractGroupMembersResponse.GetContractGroupMembersResponseV0.AsObject,
2640
+ }
2641
+
2642
+ export class ContractMembers extends jspb.Message {
2643
+ clearContractIdsList(): void;
2644
+ getContractIdsList(): Array<Uint8Array | string>;
2645
+ getContractIdsList_asU8(): Array<Uint8Array>;
2646
+ getContractIdsList_asB64(): Array<string>;
2647
+ setContractIdsList(value: Array<Uint8Array | string>): void;
2648
+ addContractIds(value: Uint8Array | string, index?: number): Uint8Array | string;
2649
+
2650
+ serializeBinary(): Uint8Array;
2651
+ toObject(includeInstance?: boolean): ContractMembers.AsObject;
2652
+ static toObject(includeInstance: boolean, msg: ContractMembers): ContractMembers.AsObject;
2653
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2654
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2655
+ static serializeBinaryToWriter(message: ContractMembers, writer: jspb.BinaryWriter): void;
2656
+ static deserializeBinary(bytes: Uint8Array): ContractMembers;
2657
+ static deserializeBinaryFromReader(message: ContractMembers, reader: jspb.BinaryReader): ContractMembers;
2658
+ }
2659
+
2660
+ export namespace ContractMembers {
2661
+ export type AsObject = {
2662
+ contractIdsList: Array<Uint8Array | string>,
2663
+ }
2664
+ }
2665
+
2666
+ export class DocumentTypeMembers extends jspb.Message {
2667
+ clearDocumentTypesList(): void;
2668
+ getDocumentTypesList(): Array<ContractGroupDocumentTypeMember>;
2669
+ setDocumentTypesList(value: Array<ContractGroupDocumentTypeMember>): void;
2670
+ addDocumentTypes(value?: ContractGroupDocumentTypeMember, index?: number): ContractGroupDocumentTypeMember;
2671
+
2672
+ serializeBinary(): Uint8Array;
2673
+ toObject(includeInstance?: boolean): DocumentTypeMembers.AsObject;
2674
+ static toObject(includeInstance: boolean, msg: DocumentTypeMembers): DocumentTypeMembers.AsObject;
2675
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2676
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2677
+ static serializeBinaryToWriter(message: DocumentTypeMembers, writer: jspb.BinaryWriter): void;
2678
+ static deserializeBinary(bytes: Uint8Array): DocumentTypeMembers;
2679
+ static deserializeBinaryFromReader(message: DocumentTypeMembers, reader: jspb.BinaryReader): DocumentTypeMembers;
2680
+ }
2681
+
2682
+ export namespace DocumentTypeMembers {
2683
+ export type AsObject = {
2684
+ documentTypesList: Array<ContractGroupDocumentTypeMember.AsObject>,
2685
+ }
2686
+ }
2687
+
2688
+ export class TokenMembers extends jspb.Message {
2689
+ clearTokensList(): void;
2690
+ getTokensList(): Array<ContractGroupTokenMember>;
2691
+ setTokensList(value: Array<ContractGroupTokenMember>): void;
2692
+ addTokens(value?: ContractGroupTokenMember, index?: number): ContractGroupTokenMember;
2693
+
2694
+ serializeBinary(): Uint8Array;
2695
+ toObject(includeInstance?: boolean): TokenMembers.AsObject;
2696
+ static toObject(includeInstance: boolean, msg: TokenMembers): TokenMembers.AsObject;
2697
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2698
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2699
+ static serializeBinaryToWriter(message: TokenMembers, writer: jspb.BinaryWriter): void;
2700
+ static deserializeBinary(bytes: Uint8Array): TokenMembers;
2701
+ static deserializeBinaryFromReader(message: TokenMembers, reader: jspb.BinaryReader): TokenMembers;
2702
+ }
2703
+
2704
+ export namespace TokenMembers {
2705
+ export type AsObject = {
2706
+ tokensList: Array<ContractGroupTokenMember.AsObject>,
2707
+ }
2708
+ }
2709
+
2710
+ export class GetContractGroupMembersResponseV0 extends jspb.Message {
2711
+ hasContracts(): boolean;
2712
+ clearContracts(): void;
2713
+ getContracts(): GetContractGroupMembersResponse.ContractMembers | undefined;
2714
+ setContracts(value?: GetContractGroupMembersResponse.ContractMembers): void;
2715
+
2716
+ hasDocumentTypes(): boolean;
2717
+ clearDocumentTypes(): void;
2718
+ getDocumentTypes(): GetContractGroupMembersResponse.DocumentTypeMembers | undefined;
2719
+ setDocumentTypes(value?: GetContractGroupMembersResponse.DocumentTypeMembers): void;
2720
+
2721
+ hasTokens(): boolean;
2722
+ clearTokens(): void;
2723
+ getTokens(): GetContractGroupMembersResponse.TokenMembers | undefined;
2724
+ setTokens(value?: GetContractGroupMembersResponse.TokenMembers): void;
2725
+
2726
+ hasProof(): boolean;
2727
+ clearProof(): void;
2728
+ getProof(): Proof | undefined;
2729
+ setProof(value?: Proof): void;
2730
+
2731
+ hasMetadata(): boolean;
2732
+ clearMetadata(): void;
2733
+ getMetadata(): ResponseMetadata | undefined;
2734
+ setMetadata(value?: ResponseMetadata): void;
2735
+
2736
+ getResultCase(): GetContractGroupMembersResponseV0.ResultCase;
2737
+ serializeBinary(): Uint8Array;
2738
+ toObject(includeInstance?: boolean): GetContractGroupMembersResponseV0.AsObject;
2739
+ static toObject(includeInstance: boolean, msg: GetContractGroupMembersResponseV0): GetContractGroupMembersResponseV0.AsObject;
2740
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2741
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2742
+ static serializeBinaryToWriter(message: GetContractGroupMembersResponseV0, writer: jspb.BinaryWriter): void;
2743
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupMembersResponseV0;
2744
+ static deserializeBinaryFromReader(message: GetContractGroupMembersResponseV0, reader: jspb.BinaryReader): GetContractGroupMembersResponseV0;
2745
+ }
2746
+
2747
+ export namespace GetContractGroupMembersResponseV0 {
2748
+ export type AsObject = {
2749
+ contracts?: GetContractGroupMembersResponse.ContractMembers.AsObject,
2750
+ documentTypes?: GetContractGroupMembersResponse.DocumentTypeMembers.AsObject,
2751
+ tokens?: GetContractGroupMembersResponse.TokenMembers.AsObject,
2752
+ proof?: Proof.AsObject,
2753
+ metadata?: ResponseMetadata.AsObject,
2754
+ }
2755
+
2756
+ export enum ResultCase {
2757
+ RESULT_NOT_SET = 0,
2758
+ CONTRACTS = 1,
2759
+ DOCUMENT_TYPES = 2,
2760
+ TOKENS = 3,
2761
+ PROOF = 4,
2762
+ }
2763
+ }
2764
+
2765
+ export enum VersionCase {
2766
+ VERSION_NOT_SET = 0,
2767
+ V0 = 1,
2768
+ }
2769
+ }
2770
+
2771
+ export class ContractModerationDocument extends jspb.Message {
2772
+ getDocumentTypeName(): string;
2773
+ setDocumentTypeName(value: string): void;
2774
+
2775
+ getDocumentId(): Uint8Array | string;
2776
+ getDocumentId_asU8(): Uint8Array;
2777
+ getDocumentId_asB64(): string;
2778
+ setDocumentId(value: Uint8Array | string): void;
2779
+
2780
+ serializeBinary(): Uint8Array;
2781
+ toObject(includeInstance?: boolean): ContractModerationDocument.AsObject;
2782
+ static toObject(includeInstance: boolean, msg: ContractModerationDocument): ContractModerationDocument.AsObject;
2783
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2784
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2785
+ static serializeBinaryToWriter(message: ContractModerationDocument, writer: jspb.BinaryWriter): void;
2786
+ static deserializeBinary(bytes: Uint8Array): ContractModerationDocument;
2787
+ static deserializeBinaryFromReader(message: ContractModerationDocument, reader: jspb.BinaryReader): ContractModerationDocument;
2788
+ }
2789
+
2790
+ export namespace ContractModerationDocument {
2791
+ export type AsObject = {
2792
+ documentTypeName: string,
2793
+ documentId: Uint8Array | string,
2794
+ }
2795
+ }
2796
+
2797
+ export class ContractModerationReason extends jspb.Message {
2798
+ hasCode(): boolean;
2799
+ clearCode(): void;
2800
+ getCode(): number;
2801
+ setCode(value: number): void;
2802
+
2803
+ getText(): string;
2804
+ setText(value: string): void;
2805
+
2806
+ clearDocumentsList(): void;
2807
+ getDocumentsList(): Array<ContractModerationDocument>;
2808
+ setDocumentsList(value: Array<ContractModerationDocument>): void;
2809
+ addDocuments(value?: ContractModerationDocument, index?: number): ContractModerationDocument;
2810
+
2811
+ hasReasonDocumentId(): boolean;
2812
+ clearReasonDocumentId(): void;
2813
+ getReasonDocumentId(): Uint8Array | string;
2814
+ getReasonDocumentId_asU8(): Uint8Array;
2815
+ getReasonDocumentId_asB64(): string;
2816
+ setReasonDocumentId(value: Uint8Array | string): void;
2817
+
2818
+ serializeBinary(): Uint8Array;
2819
+ toObject(includeInstance?: boolean): ContractModerationReason.AsObject;
2820
+ static toObject(includeInstance: boolean, msg: ContractModerationReason): ContractModerationReason.AsObject;
2821
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2822
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2823
+ static serializeBinaryToWriter(message: ContractModerationReason, writer: jspb.BinaryWriter): void;
2824
+ static deserializeBinary(bytes: Uint8Array): ContractModerationReason;
2825
+ static deserializeBinaryFromReader(message: ContractModerationReason, reader: jspb.BinaryReader): ContractModerationReason;
2826
+ }
2827
+
2828
+ export namespace ContractModerationReason {
2829
+ export type AsObject = {
2830
+ code: number,
2831
+ text: string,
2832
+ documentsList: Array<ContractModerationDocument.AsObject>,
2833
+ reasonDocumentId: Uint8Array | string,
2834
+ }
2835
+ }
2836
+
2837
+ export class ContractWarning extends jspb.Message {
2838
+ getWarnedAt(): number;
2839
+ setWarnedAt(value: number): void;
2840
+
2841
+ hasReason(): boolean;
2842
+ clearReason(): void;
2843
+ getReason(): ContractModerationReason | undefined;
2844
+ setReason(value?: ContractModerationReason): void;
2845
+
2846
+ serializeBinary(): Uint8Array;
2847
+ toObject(includeInstance?: boolean): ContractWarning.AsObject;
2848
+ static toObject(includeInstance: boolean, msg: ContractWarning): ContractWarning.AsObject;
2849
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2850
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2851
+ static serializeBinaryToWriter(message: ContractWarning, writer: jspb.BinaryWriter): void;
2852
+ static deserializeBinary(bytes: Uint8Array): ContractWarning;
2853
+ static deserializeBinaryFromReader(message: ContractWarning, reader: jspb.BinaryReader): ContractWarning;
2854
+ }
2855
+
2856
+ export namespace ContractWarning {
2857
+ export type AsObject = {
2858
+ warnedAt: number,
2859
+ reason?: ContractModerationReason.AsObject,
2860
+ }
2861
+ }
2862
+
2863
+ export class GetContractModerationStatusRequest extends jspb.Message {
2864
+ hasV0(): boolean;
2865
+ clearV0(): void;
2866
+ getV0(): GetContractModerationStatusRequest.GetContractModerationStatusRequestV0 | undefined;
2867
+ setV0(value?: GetContractModerationStatusRequest.GetContractModerationStatusRequestV0): void;
2868
+
2869
+ getVersionCase(): GetContractModerationStatusRequest.VersionCase;
2870
+ serializeBinary(): Uint8Array;
2871
+ toObject(includeInstance?: boolean): GetContractModerationStatusRequest.AsObject;
2872
+ static toObject(includeInstance: boolean, msg: GetContractModerationStatusRequest): GetContractModerationStatusRequest.AsObject;
2873
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2874
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2875
+ static serializeBinaryToWriter(message: GetContractModerationStatusRequest, writer: jspb.BinaryWriter): void;
2876
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationStatusRequest;
2877
+ static deserializeBinaryFromReader(message: GetContractModerationStatusRequest, reader: jspb.BinaryReader): GetContractModerationStatusRequest;
2878
+ }
2879
+
2880
+ export namespace GetContractModerationStatusRequest {
2881
+ export type AsObject = {
2882
+ v0?: GetContractModerationStatusRequest.GetContractModerationStatusRequestV0.AsObject,
2883
+ }
2884
+
2885
+ export class GetContractModerationStatusRequestV0 extends jspb.Message {
2886
+ getContractId(): Uint8Array | string;
2887
+ getContractId_asU8(): Uint8Array;
2888
+ getContractId_asB64(): string;
2889
+ setContractId(value: Uint8Array | string): void;
2890
+
2891
+ getIdentityId(): Uint8Array | string;
2892
+ getIdentityId_asU8(): Uint8Array;
2893
+ getIdentityId_asB64(): string;
2894
+ setIdentityId(value: Uint8Array | string): void;
2895
+
2896
+ clearListsList(): void;
2897
+ getListsList(): Array<ContractModerationListMap[keyof ContractModerationListMap]>;
2898
+ setListsList(value: Array<ContractModerationListMap[keyof ContractModerationListMap]>): void;
2899
+ addLists(value: ContractModerationListMap[keyof ContractModerationListMap], index?: number): ContractModerationListMap[keyof ContractModerationListMap];
2900
+
2901
+ getProve(): boolean;
2902
+ setProve(value: boolean): void;
2903
+
2904
+ serializeBinary(): Uint8Array;
2905
+ toObject(includeInstance?: boolean): GetContractModerationStatusRequestV0.AsObject;
2906
+ static toObject(includeInstance: boolean, msg: GetContractModerationStatusRequestV0): GetContractModerationStatusRequestV0.AsObject;
2907
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2908
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2909
+ static serializeBinaryToWriter(message: GetContractModerationStatusRequestV0, writer: jspb.BinaryWriter): void;
2910
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationStatusRequestV0;
2911
+ static deserializeBinaryFromReader(message: GetContractModerationStatusRequestV0, reader: jspb.BinaryReader): GetContractModerationStatusRequestV0;
2912
+ }
2913
+
2914
+ export namespace GetContractModerationStatusRequestV0 {
2915
+ export type AsObject = {
2916
+ contractId: Uint8Array | string,
2917
+ identityId: Uint8Array | string,
2918
+ listsList: Array<ContractModerationListMap[keyof ContractModerationListMap]>,
2919
+ prove: boolean,
2920
+ }
2921
+ }
2922
+
2923
+ export enum VersionCase {
2924
+ VERSION_NOT_SET = 0,
2925
+ V0 = 1,
2926
+ }
2927
+ }
2928
+
2929
+ export class GetContractModerationStatusResponse extends jspb.Message {
2930
+ hasV0(): boolean;
2931
+ clearV0(): void;
2932
+ getV0(): GetContractModerationStatusResponse.GetContractModerationStatusResponseV0 | undefined;
2933
+ setV0(value?: GetContractModerationStatusResponse.GetContractModerationStatusResponseV0): void;
2934
+
2935
+ getVersionCase(): GetContractModerationStatusResponse.VersionCase;
2936
+ serializeBinary(): Uint8Array;
2937
+ toObject(includeInstance?: boolean): GetContractModerationStatusResponse.AsObject;
2938
+ static toObject(includeInstance: boolean, msg: GetContractModerationStatusResponse): GetContractModerationStatusResponse.AsObject;
2939
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2940
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2941
+ static serializeBinaryToWriter(message: GetContractModerationStatusResponse, writer: jspb.BinaryWriter): void;
2942
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationStatusResponse;
2943
+ static deserializeBinaryFromReader(message: GetContractModerationStatusResponse, reader: jspb.BinaryReader): GetContractModerationStatusResponse;
2944
+ }
2945
+
2946
+ export namespace GetContractModerationStatusResponse {
2947
+ export type AsObject = {
2948
+ v0?: GetContractModerationStatusResponse.GetContractModerationStatusResponseV0.AsObject,
2949
+ }
2950
+
2951
+ export class ContractModerationStatus extends jspb.Message {
2952
+ hasBanned(): boolean;
2953
+ clearBanned(): void;
2954
+ getBanned(): boolean;
2955
+ setBanned(value: boolean): void;
2956
+
2957
+ hasSuspendedUntil(): boolean;
2958
+ clearSuspendedUntil(): void;
2959
+ getSuspendedUntil(): number;
2960
+ setSuspendedUntil(value: number): void;
2961
+
2962
+ clearListsList(): void;
2963
+ getListsList(): Array<ContractModerationListMap[keyof ContractModerationListMap]>;
2964
+ setListsList(value: Array<ContractModerationListMap[keyof ContractModerationListMap]>): void;
2965
+ addLists(value: ContractModerationListMap[keyof ContractModerationListMap], index?: number): ContractModerationListMap[keyof ContractModerationListMap];
2966
+
2967
+ hasBanReason(): boolean;
2968
+ clearBanReason(): void;
2969
+ getBanReason(): ContractModerationReason | undefined;
2970
+ setBanReason(value?: ContractModerationReason): void;
2971
+
2972
+ hasSuspensionReason(): boolean;
2973
+ clearSuspensionReason(): void;
2974
+ getSuspensionReason(): ContractModerationReason | undefined;
2975
+ setSuspensionReason(value?: ContractModerationReason): void;
2976
+
2977
+ clearWarningsList(): void;
2978
+ getWarningsList(): Array<ContractWarning>;
2979
+ setWarningsList(value: Array<ContractWarning>): void;
2980
+ addWarnings(value?: ContractWarning, index?: number): ContractWarning;
2981
+
2982
+ serializeBinary(): Uint8Array;
2983
+ toObject(includeInstance?: boolean): ContractModerationStatus.AsObject;
2984
+ static toObject(includeInstance: boolean, msg: ContractModerationStatus): ContractModerationStatus.AsObject;
2985
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
2986
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
2987
+ static serializeBinaryToWriter(message: ContractModerationStatus, writer: jspb.BinaryWriter): void;
2988
+ static deserializeBinary(bytes: Uint8Array): ContractModerationStatus;
2989
+ static deserializeBinaryFromReader(message: ContractModerationStatus, reader: jspb.BinaryReader): ContractModerationStatus;
2990
+ }
2991
+
2992
+ export namespace ContractModerationStatus {
2993
+ export type AsObject = {
2994
+ banned: boolean,
2995
+ suspendedUntil: number,
2996
+ listsList: Array<ContractModerationListMap[keyof ContractModerationListMap]>,
2997
+ banReason?: ContractModerationReason.AsObject,
2998
+ suspensionReason?: ContractModerationReason.AsObject,
2999
+ warningsList: Array<ContractWarning.AsObject>,
3000
+ }
3001
+ }
3002
+
3003
+ export class GetContractModerationStatusResponseV0 extends jspb.Message {
3004
+ hasStatus(): boolean;
3005
+ clearStatus(): void;
3006
+ getStatus(): GetContractModerationStatusResponse.ContractModerationStatus | undefined;
3007
+ setStatus(value?: GetContractModerationStatusResponse.ContractModerationStatus): void;
3008
+
3009
+ hasProof(): boolean;
3010
+ clearProof(): void;
3011
+ getProof(): Proof | undefined;
3012
+ setProof(value?: Proof): void;
3013
+
3014
+ hasMetadata(): boolean;
3015
+ clearMetadata(): void;
3016
+ getMetadata(): ResponseMetadata | undefined;
3017
+ setMetadata(value?: ResponseMetadata): void;
3018
+
3019
+ getResultCase(): GetContractModerationStatusResponseV0.ResultCase;
3020
+ serializeBinary(): Uint8Array;
3021
+ toObject(includeInstance?: boolean): GetContractModerationStatusResponseV0.AsObject;
3022
+ static toObject(includeInstance: boolean, msg: GetContractModerationStatusResponseV0): GetContractModerationStatusResponseV0.AsObject;
3023
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3024
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3025
+ static serializeBinaryToWriter(message: GetContractModerationStatusResponseV0, writer: jspb.BinaryWriter): void;
3026
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationStatusResponseV0;
3027
+ static deserializeBinaryFromReader(message: GetContractModerationStatusResponseV0, reader: jspb.BinaryReader): GetContractModerationStatusResponseV0;
3028
+ }
3029
+
3030
+ export namespace GetContractModerationStatusResponseV0 {
3031
+ export type AsObject = {
3032
+ status?: GetContractModerationStatusResponse.ContractModerationStatus.AsObject,
3033
+ proof?: Proof.AsObject,
3034
+ metadata?: ResponseMetadata.AsObject,
3035
+ }
3036
+
3037
+ export enum ResultCase {
3038
+ RESULT_NOT_SET = 0,
3039
+ STATUS = 1,
3040
+ PROOF = 2,
3041
+ }
3042
+ }
3043
+
3044
+ export enum VersionCase {
3045
+ VERSION_NOT_SET = 0,
3046
+ V0 = 1,
3047
+ }
3048
+ }
3049
+
3050
+ export class GetContractModerationEntriesRequest extends jspb.Message {
3051
+ hasV0(): boolean;
3052
+ clearV0(): void;
3053
+ getV0(): GetContractModerationEntriesRequest.GetContractModerationEntriesRequestV0 | undefined;
3054
+ setV0(value?: GetContractModerationEntriesRequest.GetContractModerationEntriesRequestV0): void;
3055
+
3056
+ getVersionCase(): GetContractModerationEntriesRequest.VersionCase;
3057
+ serializeBinary(): Uint8Array;
3058
+ toObject(includeInstance?: boolean): GetContractModerationEntriesRequest.AsObject;
3059
+ static toObject(includeInstance: boolean, msg: GetContractModerationEntriesRequest): GetContractModerationEntriesRequest.AsObject;
3060
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3061
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3062
+ static serializeBinaryToWriter(message: GetContractModerationEntriesRequest, writer: jspb.BinaryWriter): void;
3063
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationEntriesRequest;
3064
+ static deserializeBinaryFromReader(message: GetContractModerationEntriesRequest, reader: jspb.BinaryReader): GetContractModerationEntriesRequest;
3065
+ }
3066
+
3067
+ export namespace GetContractModerationEntriesRequest {
3068
+ export type AsObject = {
3069
+ v0?: GetContractModerationEntriesRequest.GetContractModerationEntriesRequestV0.AsObject,
3070
+ }
3071
+
3072
+ export class GetContractModerationEntriesRequestV0 extends jspb.Message {
3073
+ getContractId(): Uint8Array | string;
3074
+ getContractId_asU8(): Uint8Array;
3075
+ getContractId_asB64(): string;
3076
+ setContractId(value: Uint8Array | string): void;
3077
+
3078
+ getList(): ContractModerationListMap[keyof ContractModerationListMap];
3079
+ setList(value: ContractModerationListMap[keyof ContractModerationListMap]): void;
3080
+
3081
+ hasStartAfter(): boolean;
3082
+ clearStartAfter(): void;
3083
+ getStartAfter(): Uint8Array | string;
3084
+ getStartAfter_asU8(): Uint8Array;
3085
+ getStartAfter_asB64(): string;
3086
+ setStartAfter(value: Uint8Array | string): void;
3087
+
3088
+ hasLimit(): boolean;
3089
+ clearLimit(): void;
3090
+ getLimit(): number;
3091
+ setLimit(value: number): void;
3092
+
3093
+ getProve(): boolean;
3094
+ setProve(value: boolean): void;
3095
+
3096
+ serializeBinary(): Uint8Array;
3097
+ toObject(includeInstance?: boolean): GetContractModerationEntriesRequestV0.AsObject;
3098
+ static toObject(includeInstance: boolean, msg: GetContractModerationEntriesRequestV0): GetContractModerationEntriesRequestV0.AsObject;
3099
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3100
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3101
+ static serializeBinaryToWriter(message: GetContractModerationEntriesRequestV0, writer: jspb.BinaryWriter): void;
3102
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationEntriesRequestV0;
3103
+ static deserializeBinaryFromReader(message: GetContractModerationEntriesRequestV0, reader: jspb.BinaryReader): GetContractModerationEntriesRequestV0;
3104
+ }
3105
+
3106
+ export namespace GetContractModerationEntriesRequestV0 {
3107
+ export type AsObject = {
3108
+ contractId: Uint8Array | string,
3109
+ list: ContractModerationListMap[keyof ContractModerationListMap],
3110
+ startAfter: Uint8Array | string,
3111
+ limit: number,
3112
+ prove: boolean,
3113
+ }
3114
+ }
3115
+
3116
+ export enum VersionCase {
3117
+ VERSION_NOT_SET = 0,
3118
+ V0 = 1,
3119
+ }
3120
+ }
3121
+
3122
+ export class GetContractModerationEntriesResponse extends jspb.Message {
3123
+ hasV0(): boolean;
3124
+ clearV0(): void;
3125
+ getV0(): GetContractModerationEntriesResponse.GetContractModerationEntriesResponseV0 | undefined;
3126
+ setV0(value?: GetContractModerationEntriesResponse.GetContractModerationEntriesResponseV0): void;
3127
+
3128
+ getVersionCase(): GetContractModerationEntriesResponse.VersionCase;
3129
+ serializeBinary(): Uint8Array;
3130
+ toObject(includeInstance?: boolean): GetContractModerationEntriesResponse.AsObject;
3131
+ static toObject(includeInstance: boolean, msg: GetContractModerationEntriesResponse): GetContractModerationEntriesResponse.AsObject;
3132
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3133
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3134
+ static serializeBinaryToWriter(message: GetContractModerationEntriesResponse, writer: jspb.BinaryWriter): void;
3135
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationEntriesResponse;
3136
+ static deserializeBinaryFromReader(message: GetContractModerationEntriesResponse, reader: jspb.BinaryReader): GetContractModerationEntriesResponse;
3137
+ }
3138
+
3139
+ export namespace GetContractModerationEntriesResponse {
3140
+ export type AsObject = {
3141
+ v0?: GetContractModerationEntriesResponse.GetContractModerationEntriesResponseV0.AsObject,
3142
+ }
3143
+
3144
+ export class ContractModerationEntry extends jspb.Message {
3145
+ getIdentityId(): Uint8Array | string;
3146
+ getIdentityId_asU8(): Uint8Array;
3147
+ getIdentityId_asB64(): string;
3148
+ setIdentityId(value: Uint8Array | string): void;
3149
+
3150
+ hasUntil(): boolean;
3151
+ clearUntil(): void;
3152
+ getUntil(): number;
3153
+ setUntil(value: number): void;
3154
+
3155
+ hasReason(): boolean;
3156
+ clearReason(): void;
3157
+ getReason(): ContractModerationReason | undefined;
3158
+ setReason(value?: ContractModerationReason): void;
3159
+
3160
+ clearWarningsList(): void;
3161
+ getWarningsList(): Array<ContractWarning>;
3162
+ setWarningsList(value: Array<ContractWarning>): void;
3163
+ addWarnings(value?: ContractWarning, index?: number): ContractWarning;
3164
+
3165
+ serializeBinary(): Uint8Array;
3166
+ toObject(includeInstance?: boolean): ContractModerationEntry.AsObject;
3167
+ static toObject(includeInstance: boolean, msg: ContractModerationEntry): ContractModerationEntry.AsObject;
3168
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3169
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3170
+ static serializeBinaryToWriter(message: ContractModerationEntry, writer: jspb.BinaryWriter): void;
3171
+ static deserializeBinary(bytes: Uint8Array): ContractModerationEntry;
3172
+ static deserializeBinaryFromReader(message: ContractModerationEntry, reader: jspb.BinaryReader): ContractModerationEntry;
3173
+ }
3174
+
3175
+ export namespace ContractModerationEntry {
3176
+ export type AsObject = {
3177
+ identityId: Uint8Array | string,
3178
+ until: number,
3179
+ reason?: ContractModerationReason.AsObject,
3180
+ warningsList: Array<ContractWarning.AsObject>,
3181
+ }
3182
+ }
3183
+
3184
+ export class ContractModerationEntries extends jspb.Message {
3185
+ clearEntriesList(): void;
3186
+ getEntriesList(): Array<GetContractModerationEntriesResponse.ContractModerationEntry>;
3187
+ setEntriesList(value: Array<GetContractModerationEntriesResponse.ContractModerationEntry>): void;
3188
+ addEntries(value?: GetContractModerationEntriesResponse.ContractModerationEntry, index?: number): GetContractModerationEntriesResponse.ContractModerationEntry;
3189
+
3190
+ serializeBinary(): Uint8Array;
3191
+ toObject(includeInstance?: boolean): ContractModerationEntries.AsObject;
3192
+ static toObject(includeInstance: boolean, msg: ContractModerationEntries): ContractModerationEntries.AsObject;
3193
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3194
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3195
+ static serializeBinaryToWriter(message: ContractModerationEntries, writer: jspb.BinaryWriter): void;
3196
+ static deserializeBinary(bytes: Uint8Array): ContractModerationEntries;
3197
+ static deserializeBinaryFromReader(message: ContractModerationEntries, reader: jspb.BinaryReader): ContractModerationEntries;
3198
+ }
3199
+
3200
+ export namespace ContractModerationEntries {
3201
+ export type AsObject = {
3202
+ entriesList: Array<GetContractModerationEntriesResponse.ContractModerationEntry.AsObject>,
3203
+ }
3204
+ }
3205
+
3206
+ export class GetContractModerationEntriesResponseV0 extends jspb.Message {
3207
+ hasEntries(): boolean;
3208
+ clearEntries(): void;
3209
+ getEntries(): GetContractModerationEntriesResponse.ContractModerationEntries | undefined;
3210
+ setEntries(value?: GetContractModerationEntriesResponse.ContractModerationEntries): void;
3211
+
3212
+ hasProof(): boolean;
3213
+ clearProof(): void;
3214
+ getProof(): Proof | undefined;
3215
+ setProof(value?: Proof): void;
3216
+
3217
+ hasMetadata(): boolean;
3218
+ clearMetadata(): void;
3219
+ getMetadata(): ResponseMetadata | undefined;
3220
+ setMetadata(value?: ResponseMetadata): void;
3221
+
3222
+ getResultCase(): GetContractModerationEntriesResponseV0.ResultCase;
3223
+ serializeBinary(): Uint8Array;
3224
+ toObject(includeInstance?: boolean): GetContractModerationEntriesResponseV0.AsObject;
3225
+ static toObject(includeInstance: boolean, msg: GetContractModerationEntriesResponseV0): GetContractModerationEntriesResponseV0.AsObject;
3226
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3227
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3228
+ static serializeBinaryToWriter(message: GetContractModerationEntriesResponseV0, writer: jspb.BinaryWriter): void;
3229
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationEntriesResponseV0;
3230
+ static deserializeBinaryFromReader(message: GetContractModerationEntriesResponseV0, reader: jspb.BinaryReader): GetContractModerationEntriesResponseV0;
3231
+ }
3232
+
3233
+ export namespace GetContractModerationEntriesResponseV0 {
3234
+ export type AsObject = {
3235
+ entries?: GetContractModerationEntriesResponse.ContractModerationEntries.AsObject,
3236
+ proof?: Proof.AsObject,
3237
+ metadata?: ResponseMetadata.AsObject,
3238
+ }
3239
+
3240
+ export enum ResultCase {
3241
+ RESULT_NOT_SET = 0,
3242
+ ENTRIES = 1,
3243
+ PROOF = 2,
3244
+ }
3245
+ }
3246
+
3247
+ export enum VersionCase {
3248
+ VERSION_NOT_SET = 0,
3249
+ V0 = 1,
3250
+ }
3251
+ }
3252
+
3253
+ export class GetContractDocumentRemovalsRequest extends jspb.Message {
3254
+ hasV0(): boolean;
3255
+ clearV0(): void;
3256
+ getV0(): GetContractDocumentRemovalsRequest.GetContractDocumentRemovalsRequestV0 | undefined;
3257
+ setV0(value?: GetContractDocumentRemovalsRequest.GetContractDocumentRemovalsRequestV0): void;
3258
+
3259
+ getVersionCase(): GetContractDocumentRemovalsRequest.VersionCase;
3260
+ serializeBinary(): Uint8Array;
3261
+ toObject(includeInstance?: boolean): GetContractDocumentRemovalsRequest.AsObject;
3262
+ static toObject(includeInstance: boolean, msg: GetContractDocumentRemovalsRequest): GetContractDocumentRemovalsRequest.AsObject;
3263
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3264
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3265
+ static serializeBinaryToWriter(message: GetContractDocumentRemovalsRequest, writer: jspb.BinaryWriter): void;
3266
+ static deserializeBinary(bytes: Uint8Array): GetContractDocumentRemovalsRequest;
3267
+ static deserializeBinaryFromReader(message: GetContractDocumentRemovalsRequest, reader: jspb.BinaryReader): GetContractDocumentRemovalsRequest;
3268
+ }
3269
+
3270
+ export namespace GetContractDocumentRemovalsRequest {
3271
+ export type AsObject = {
3272
+ v0?: GetContractDocumentRemovalsRequest.GetContractDocumentRemovalsRequestV0.AsObject,
3273
+ }
3274
+
3275
+ export class DocumentIds extends jspb.Message {
3276
+ clearDocumentIdsList(): void;
3277
+ getDocumentIdsList(): Array<Uint8Array | string>;
3278
+ getDocumentIdsList_asU8(): Array<Uint8Array>;
3279
+ getDocumentIdsList_asB64(): Array<string>;
3280
+ setDocumentIdsList(value: Array<Uint8Array | string>): void;
3281
+ addDocumentIds(value: Uint8Array | string, index?: number): Uint8Array | string;
3282
+
3283
+ serializeBinary(): Uint8Array;
3284
+ toObject(includeInstance?: boolean): DocumentIds.AsObject;
3285
+ static toObject(includeInstance: boolean, msg: DocumentIds): DocumentIds.AsObject;
3286
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3287
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3288
+ static serializeBinaryToWriter(message: DocumentIds, writer: jspb.BinaryWriter): void;
3289
+ static deserializeBinary(bytes: Uint8Array): DocumentIds;
3290
+ static deserializeBinaryFromReader(message: DocumentIds, reader: jspb.BinaryReader): DocumentIds;
3291
+ }
3292
+
3293
+ export namespace DocumentIds {
3294
+ export type AsObject = {
3295
+ documentIdsList: Array<Uint8Array | string>,
3296
+ }
3297
+ }
3298
+
3299
+ export class Page extends jspb.Message {
3300
+ hasStartAfter(): boolean;
3301
+ clearStartAfter(): void;
3302
+ getStartAfter(): Uint8Array | string;
3303
+ getStartAfter_asU8(): Uint8Array;
3304
+ getStartAfter_asB64(): string;
3305
+ setStartAfter(value: Uint8Array | string): void;
3306
+
3307
+ hasLimit(): boolean;
3308
+ clearLimit(): void;
3309
+ getLimit(): number;
3310
+ setLimit(value: number): void;
3311
+
3312
+ serializeBinary(): Uint8Array;
3313
+ toObject(includeInstance?: boolean): Page.AsObject;
3314
+ static toObject(includeInstance: boolean, msg: Page): Page.AsObject;
3315
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3316
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3317
+ static serializeBinaryToWriter(message: Page, writer: jspb.BinaryWriter): void;
3318
+ static deserializeBinary(bytes: Uint8Array): Page;
3319
+ static deserializeBinaryFromReader(message: Page, reader: jspb.BinaryReader): Page;
3320
+ }
3321
+
3322
+ export namespace Page {
3323
+ export type AsObject = {
3324
+ startAfter: Uint8Array | string,
3325
+ limit: number,
3326
+ }
3327
+ }
3328
+
3329
+ export class GetContractDocumentRemovalsRequestV0 extends jspb.Message {
3330
+ getContractId(): Uint8Array | string;
3331
+ getContractId_asU8(): Uint8Array;
3332
+ getContractId_asB64(): string;
3333
+ setContractId(value: Uint8Array | string): void;
3334
+
3335
+ getDocumentTypeName(): string;
3336
+ setDocumentTypeName(value: string): void;
3337
+
3338
+ hasDocumentIds(): boolean;
3339
+ clearDocumentIds(): void;
3340
+ getDocumentIds(): GetContractDocumentRemovalsRequest.DocumentIds | undefined;
3341
+ setDocumentIds(value?: GetContractDocumentRemovalsRequest.DocumentIds): void;
3342
+
3343
+ hasPage(): boolean;
3344
+ clearPage(): void;
3345
+ getPage(): GetContractDocumentRemovalsRequest.Page | undefined;
3346
+ setPage(value?: GetContractDocumentRemovalsRequest.Page): void;
3347
+
3348
+ getProve(): boolean;
3349
+ setProve(value: boolean): void;
3350
+
3351
+ getSelectionCase(): GetContractDocumentRemovalsRequestV0.SelectionCase;
3352
+ serializeBinary(): Uint8Array;
3353
+ toObject(includeInstance?: boolean): GetContractDocumentRemovalsRequestV0.AsObject;
3354
+ static toObject(includeInstance: boolean, msg: GetContractDocumentRemovalsRequestV0): GetContractDocumentRemovalsRequestV0.AsObject;
3355
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3356
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3357
+ static serializeBinaryToWriter(message: GetContractDocumentRemovalsRequestV0, writer: jspb.BinaryWriter): void;
3358
+ static deserializeBinary(bytes: Uint8Array): GetContractDocumentRemovalsRequestV0;
3359
+ static deserializeBinaryFromReader(message: GetContractDocumentRemovalsRequestV0, reader: jspb.BinaryReader): GetContractDocumentRemovalsRequestV0;
3360
+ }
3361
+
3362
+ export namespace GetContractDocumentRemovalsRequestV0 {
3363
+ export type AsObject = {
3364
+ contractId: Uint8Array | string,
3365
+ documentTypeName: string,
3366
+ documentIds?: GetContractDocumentRemovalsRequest.DocumentIds.AsObject,
3367
+ page?: GetContractDocumentRemovalsRequest.Page.AsObject,
3368
+ prove: boolean,
3369
+ }
3370
+
3371
+ export enum SelectionCase {
3372
+ SELECTION_NOT_SET = 0,
3373
+ DOCUMENT_IDS = 3,
3374
+ PAGE = 4,
3375
+ }
3376
+ }
3377
+
3378
+ export enum VersionCase {
3379
+ VERSION_NOT_SET = 0,
3380
+ V0 = 1,
3381
+ }
3382
+ }
3383
+
3384
+ export class GetContractDocumentRemovalsResponse extends jspb.Message {
3385
+ hasV0(): boolean;
3386
+ clearV0(): void;
3387
+ getV0(): GetContractDocumentRemovalsResponse.GetContractDocumentRemovalsResponseV0 | undefined;
3388
+ setV0(value?: GetContractDocumentRemovalsResponse.GetContractDocumentRemovalsResponseV0): void;
3389
+
3390
+ getVersionCase(): GetContractDocumentRemovalsResponse.VersionCase;
3391
+ serializeBinary(): Uint8Array;
3392
+ toObject(includeInstance?: boolean): GetContractDocumentRemovalsResponse.AsObject;
3393
+ static toObject(includeInstance: boolean, msg: GetContractDocumentRemovalsResponse): GetContractDocumentRemovalsResponse.AsObject;
3394
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3395
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3396
+ static serializeBinaryToWriter(message: GetContractDocumentRemovalsResponse, writer: jspb.BinaryWriter): void;
3397
+ static deserializeBinary(bytes: Uint8Array): GetContractDocumentRemovalsResponse;
3398
+ static deserializeBinaryFromReader(message: GetContractDocumentRemovalsResponse, reader: jspb.BinaryReader): GetContractDocumentRemovalsResponse;
3399
+ }
3400
+
3401
+ export namespace GetContractDocumentRemovalsResponse {
3402
+ export type AsObject = {
3403
+ v0?: GetContractDocumentRemovalsResponse.GetContractDocumentRemovalsResponseV0.AsObject,
3404
+ }
3405
+
3406
+ export class ContractDocumentRestoration extends jspb.Message {
3407
+ getModeratorId(): Uint8Array | string;
3408
+ getModeratorId_asU8(): Uint8Array;
3409
+ getModeratorId_asB64(): string;
3410
+ setModeratorId(value: Uint8Array | string): void;
3411
+
3412
+ getRestoredAt(): number;
3413
+ setRestoredAt(value: number): void;
3414
+
3415
+ serializeBinary(): Uint8Array;
3416
+ toObject(includeInstance?: boolean): ContractDocumentRestoration.AsObject;
3417
+ static toObject(includeInstance: boolean, msg: ContractDocumentRestoration): ContractDocumentRestoration.AsObject;
3418
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3419
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3420
+ static serializeBinaryToWriter(message: ContractDocumentRestoration, writer: jspb.BinaryWriter): void;
3421
+ static deserializeBinary(bytes: Uint8Array): ContractDocumentRestoration;
3422
+ static deserializeBinaryFromReader(message: ContractDocumentRestoration, reader: jspb.BinaryReader): ContractDocumentRestoration;
3423
+ }
3424
+
3425
+ export namespace ContractDocumentRestoration {
3426
+ export type AsObject = {
3427
+ moderatorId: Uint8Array | string,
3428
+ restoredAt: number,
3429
+ }
3430
+ }
3431
+
3432
+ export class ContractDocumentRemoval extends jspb.Message {
3433
+ getDocumentId(): Uint8Array | string;
3434
+ getDocumentId_asU8(): Uint8Array;
3435
+ getDocumentId_asB64(): string;
3436
+ setDocumentId(value: Uint8Array | string): void;
3437
+
3438
+ getDocumentOwnerId(): Uint8Array | string;
3439
+ getDocumentOwnerId_asU8(): Uint8Array;
3440
+ getDocumentOwnerId_asB64(): string;
3441
+ setDocumentOwnerId(value: Uint8Array | string): void;
3442
+
3443
+ getModeratorId(): Uint8Array | string;
3444
+ getModeratorId_asU8(): Uint8Array;
3445
+ getModeratorId_asB64(): string;
3446
+ setModeratorId(value: Uint8Array | string): void;
3447
+
3448
+ getRemovedAt(): number;
3449
+ setRemovedAt(value: number): void;
3450
+
3451
+ hasReason(): boolean;
3452
+ clearReason(): void;
3453
+ getReason(): ContractModerationReason | undefined;
3454
+ setReason(value?: ContractModerationReason): void;
3455
+
3456
+ getDocumentHash(): Uint8Array | string;
3457
+ getDocumentHash_asU8(): Uint8Array;
3458
+ getDocumentHash_asB64(): string;
3459
+ setDocumentHash(value: Uint8Array | string): void;
3460
+
3461
+ hasRestoration(): boolean;
3462
+ clearRestoration(): void;
3463
+ getRestoration(): GetContractDocumentRemovalsResponse.ContractDocumentRestoration | undefined;
3464
+ setRestoration(value?: GetContractDocumentRemovalsResponse.ContractDocumentRestoration): void;
3465
+
3466
+ getKeptFields(): Uint8Array | string;
3467
+ getKeptFields_asU8(): Uint8Array;
3468
+ getKeptFields_asB64(): string;
3469
+ setKeptFields(value: Uint8Array | string): void;
3470
+
3471
+ serializeBinary(): Uint8Array;
3472
+ toObject(includeInstance?: boolean): ContractDocumentRemoval.AsObject;
3473
+ static toObject(includeInstance: boolean, msg: ContractDocumentRemoval): ContractDocumentRemoval.AsObject;
3474
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3475
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3476
+ static serializeBinaryToWriter(message: ContractDocumentRemoval, writer: jspb.BinaryWriter): void;
3477
+ static deserializeBinary(bytes: Uint8Array): ContractDocumentRemoval;
3478
+ static deserializeBinaryFromReader(message: ContractDocumentRemoval, reader: jspb.BinaryReader): ContractDocumentRemoval;
3479
+ }
3480
+
3481
+ export namespace ContractDocumentRemoval {
3482
+ export type AsObject = {
3483
+ documentId: Uint8Array | string,
3484
+ documentOwnerId: Uint8Array | string,
3485
+ moderatorId: Uint8Array | string,
3486
+ removedAt: number,
3487
+ reason?: ContractModerationReason.AsObject,
3488
+ documentHash: Uint8Array | string,
3489
+ restoration?: GetContractDocumentRemovalsResponse.ContractDocumentRestoration.AsObject,
3490
+ keptFields: Uint8Array | string,
3491
+ }
3492
+ }
3493
+
3494
+ export class ContractDocumentRemovals extends jspb.Message {
3495
+ clearRemovalsList(): void;
3496
+ getRemovalsList(): Array<GetContractDocumentRemovalsResponse.ContractDocumentRemoval>;
3497
+ setRemovalsList(value: Array<GetContractDocumentRemovalsResponse.ContractDocumentRemoval>): void;
3498
+ addRemovals(value?: GetContractDocumentRemovalsResponse.ContractDocumentRemoval, index?: number): GetContractDocumentRemovalsResponse.ContractDocumentRemoval;
3499
+
3500
+ serializeBinary(): Uint8Array;
3501
+ toObject(includeInstance?: boolean): ContractDocumentRemovals.AsObject;
3502
+ static toObject(includeInstance: boolean, msg: ContractDocumentRemovals): ContractDocumentRemovals.AsObject;
3503
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3504
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3505
+ static serializeBinaryToWriter(message: ContractDocumentRemovals, writer: jspb.BinaryWriter): void;
3506
+ static deserializeBinary(bytes: Uint8Array): ContractDocumentRemovals;
3507
+ static deserializeBinaryFromReader(message: ContractDocumentRemovals, reader: jspb.BinaryReader): ContractDocumentRemovals;
3508
+ }
3509
+
3510
+ export namespace ContractDocumentRemovals {
3511
+ export type AsObject = {
3512
+ removalsList: Array<GetContractDocumentRemovalsResponse.ContractDocumentRemoval.AsObject>,
3513
+ }
3514
+ }
3515
+
3516
+ export class GetContractDocumentRemovalsResponseV0 extends jspb.Message {
3517
+ hasRemovals(): boolean;
3518
+ clearRemovals(): void;
3519
+ getRemovals(): GetContractDocumentRemovalsResponse.ContractDocumentRemovals | undefined;
3520
+ setRemovals(value?: GetContractDocumentRemovalsResponse.ContractDocumentRemovals): void;
3521
+
3522
+ hasProof(): boolean;
3523
+ clearProof(): void;
3524
+ getProof(): Proof | undefined;
3525
+ setProof(value?: Proof): void;
3526
+
3527
+ hasMetadata(): boolean;
3528
+ clearMetadata(): void;
3529
+ getMetadata(): ResponseMetadata | undefined;
3530
+ setMetadata(value?: ResponseMetadata): void;
3531
+
3532
+ getResultCase(): GetContractDocumentRemovalsResponseV0.ResultCase;
3533
+ serializeBinary(): Uint8Array;
3534
+ toObject(includeInstance?: boolean): GetContractDocumentRemovalsResponseV0.AsObject;
3535
+ static toObject(includeInstance: boolean, msg: GetContractDocumentRemovalsResponseV0): GetContractDocumentRemovalsResponseV0.AsObject;
3536
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3537
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3538
+ static serializeBinaryToWriter(message: GetContractDocumentRemovalsResponseV0, writer: jspb.BinaryWriter): void;
3539
+ static deserializeBinary(bytes: Uint8Array): GetContractDocumentRemovalsResponseV0;
3540
+ static deserializeBinaryFromReader(message: GetContractDocumentRemovalsResponseV0, reader: jspb.BinaryReader): GetContractDocumentRemovalsResponseV0;
3541
+ }
3542
+
3543
+ export namespace GetContractDocumentRemovalsResponseV0 {
3544
+ export type AsObject = {
3545
+ removals?: GetContractDocumentRemovalsResponse.ContractDocumentRemovals.AsObject,
3546
+ proof?: Proof.AsObject,
3547
+ metadata?: ResponseMetadata.AsObject,
3548
+ }
3549
+
3550
+ export enum ResultCase {
3551
+ RESULT_NOT_SET = 0,
3552
+ REMOVALS = 1,
3553
+ PROOF = 2,
3554
+ }
3555
+ }
3556
+
3557
+ export enum VersionCase {
3558
+ VERSION_NOT_SET = 0,
3559
+ V0 = 1,
3560
+ }
3561
+ }
3562
+
3563
+ export class GetContractTeamActionsRequest extends jspb.Message {
3564
+ hasV0(): boolean;
3565
+ clearV0(): void;
3566
+ getV0(): GetContractTeamActionsRequest.GetContractTeamActionsRequestV0 | undefined;
3567
+ setV0(value?: GetContractTeamActionsRequest.GetContractTeamActionsRequestV0): void;
3568
+
3569
+ getVersionCase(): GetContractTeamActionsRequest.VersionCase;
3570
+ serializeBinary(): Uint8Array;
3571
+ toObject(includeInstance?: boolean): GetContractTeamActionsRequest.AsObject;
3572
+ static toObject(includeInstance: boolean, msg: GetContractTeamActionsRequest): GetContractTeamActionsRequest.AsObject;
3573
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3574
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3575
+ static serializeBinaryToWriter(message: GetContractTeamActionsRequest, writer: jspb.BinaryWriter): void;
3576
+ static deserializeBinary(bytes: Uint8Array): GetContractTeamActionsRequest;
3577
+ static deserializeBinaryFromReader(message: GetContractTeamActionsRequest, reader: jspb.BinaryReader): GetContractTeamActionsRequest;
3578
+ }
3579
+
3580
+ export namespace GetContractTeamActionsRequest {
3581
+ export type AsObject = {
3582
+ v0?: GetContractTeamActionsRequest.GetContractTeamActionsRequestV0.AsObject,
3583
+ }
3584
+
3585
+ export class StartAtActionId extends jspb.Message {
3586
+ getStartActionId(): Uint8Array | string;
3587
+ getStartActionId_asU8(): Uint8Array;
3588
+ getStartActionId_asB64(): string;
3589
+ setStartActionId(value: Uint8Array | string): void;
3590
+
3591
+ getStartActionIdIncluded(): boolean;
3592
+ setStartActionIdIncluded(value: boolean): void;
3593
+
3594
+ serializeBinary(): Uint8Array;
3595
+ toObject(includeInstance?: boolean): StartAtActionId.AsObject;
3596
+ static toObject(includeInstance: boolean, msg: StartAtActionId): StartAtActionId.AsObject;
3597
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3598
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3599
+ static serializeBinaryToWriter(message: StartAtActionId, writer: jspb.BinaryWriter): void;
3600
+ static deserializeBinary(bytes: Uint8Array): StartAtActionId;
3601
+ static deserializeBinaryFromReader(message: StartAtActionId, reader: jspb.BinaryReader): StartAtActionId;
3602
+ }
3603
+
3604
+ export namespace StartAtActionId {
3605
+ export type AsObject = {
3606
+ startActionId: Uint8Array | string,
3607
+ startActionIdIncluded: boolean,
3608
+ }
3609
+ }
3610
+
3611
+ export class GetContractTeamActionsRequestV0 extends jspb.Message {
3612
+ getContractId(): Uint8Array | string;
3613
+ getContractId_asU8(): Uint8Array;
3614
+ getContractId_asB64(): string;
3615
+ setContractId(value: Uint8Array | string): void;
3616
+
3617
+ getStatus(): GetContractTeamActionsRequest.ActionStatusMap[keyof GetContractTeamActionsRequest.ActionStatusMap];
3618
+ setStatus(value: GetContractTeamActionsRequest.ActionStatusMap[keyof GetContractTeamActionsRequest.ActionStatusMap]): void;
3619
+
3620
+ hasStartAtActionId(): boolean;
3621
+ clearStartAtActionId(): void;
3622
+ getStartAtActionId(): GetContractTeamActionsRequest.StartAtActionId | undefined;
3623
+ setStartAtActionId(value?: GetContractTeamActionsRequest.StartAtActionId): void;
3624
+
3625
+ hasCount(): boolean;
3626
+ clearCount(): void;
3627
+ getCount(): number;
3628
+ setCount(value: number): void;
3629
+
3630
+ getProve(): boolean;
3631
+ setProve(value: boolean): void;
3632
+
3633
+ serializeBinary(): Uint8Array;
3634
+ toObject(includeInstance?: boolean): GetContractTeamActionsRequestV0.AsObject;
3635
+ static toObject(includeInstance: boolean, msg: GetContractTeamActionsRequestV0): GetContractTeamActionsRequestV0.AsObject;
3636
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3637
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3638
+ static serializeBinaryToWriter(message: GetContractTeamActionsRequestV0, writer: jspb.BinaryWriter): void;
3639
+ static deserializeBinary(bytes: Uint8Array): GetContractTeamActionsRequestV0;
3640
+ static deserializeBinaryFromReader(message: GetContractTeamActionsRequestV0, reader: jspb.BinaryReader): GetContractTeamActionsRequestV0;
3641
+ }
3642
+
3643
+ export namespace GetContractTeamActionsRequestV0 {
3644
+ export type AsObject = {
3645
+ contractId: Uint8Array | string,
3646
+ status: GetContractTeamActionsRequest.ActionStatusMap[keyof GetContractTeamActionsRequest.ActionStatusMap],
3647
+ startAtActionId?: GetContractTeamActionsRequest.StartAtActionId.AsObject,
3648
+ count: number,
3649
+ prove: boolean,
3650
+ }
3651
+ }
3652
+
3653
+ export interface ActionStatusMap {
3654
+ ACTIVE: 0;
3655
+ CLOSED: 1;
3656
+ }
3657
+
3658
+ export const ActionStatus: ActionStatusMap;
3659
+
3660
+ export enum VersionCase {
3661
+ VERSION_NOT_SET = 0,
3662
+ V0 = 1,
3663
+ }
3664
+ }
3665
+
3666
+ export class GetContractTeamActionsResponse extends jspb.Message {
3667
+ hasV0(): boolean;
3668
+ clearV0(): void;
3669
+ getV0(): GetContractTeamActionsResponse.GetContractTeamActionsResponseV0 | undefined;
3670
+ setV0(value?: GetContractTeamActionsResponse.GetContractTeamActionsResponseV0): void;
3671
+
3672
+ getVersionCase(): GetContractTeamActionsResponse.VersionCase;
3673
+ serializeBinary(): Uint8Array;
3674
+ toObject(includeInstance?: boolean): GetContractTeamActionsResponse.AsObject;
3675
+ static toObject(includeInstance: boolean, msg: GetContractTeamActionsResponse): GetContractTeamActionsResponse.AsObject;
3676
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3677
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3678
+ static serializeBinaryToWriter(message: GetContractTeamActionsResponse, writer: jspb.BinaryWriter): void;
3679
+ static deserializeBinary(bytes: Uint8Array): GetContractTeamActionsResponse;
3680
+ static deserializeBinaryFromReader(message: GetContractTeamActionsResponse, reader: jspb.BinaryReader): GetContractTeamActionsResponse;
3681
+ }
3682
+
3683
+ export namespace GetContractTeamActionsResponse {
3684
+ export type AsObject = {
3685
+ v0?: GetContractTeamActionsResponse.GetContractTeamActionsResponseV0.AsObject,
3686
+ }
3687
+
3688
+ export class DeleteSettledDocument extends jspb.Message {
3689
+ getDocumentTypeName(): string;
3690
+ setDocumentTypeName(value: string): void;
3691
+
3692
+ getDocumentId(): Uint8Array | string;
3693
+ getDocumentId_asU8(): Uint8Array;
3694
+ getDocumentId_asB64(): string;
3695
+ setDocumentId(value: Uint8Array | string): void;
3696
+
3697
+ getDocumentLastModifiedAt(): number;
3698
+ setDocumentLastModifiedAt(value: number): void;
3699
+
3700
+ hasDocumentRevision(): boolean;
3701
+ clearDocumentRevision(): void;
3702
+ getDocumentRevision(): number;
3703
+ setDocumentRevision(value: number): void;
3704
+
3705
+ hasReason(): boolean;
3706
+ clearReason(): void;
3707
+ getReason(): ContractModerationReason | undefined;
3708
+ setReason(value?: ContractModerationReason): void;
3709
+
3710
+ serializeBinary(): Uint8Array;
3711
+ toObject(includeInstance?: boolean): DeleteSettledDocument.AsObject;
3712
+ static toObject(includeInstance: boolean, msg: DeleteSettledDocument): DeleteSettledDocument.AsObject;
3713
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3714
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3715
+ static serializeBinaryToWriter(message: DeleteSettledDocument, writer: jspb.BinaryWriter): void;
3716
+ static deserializeBinary(bytes: Uint8Array): DeleteSettledDocument;
3717
+ static deserializeBinaryFromReader(message: DeleteSettledDocument, reader: jspb.BinaryReader): DeleteSettledDocument;
3718
+ }
3719
+
3720
+ export namespace DeleteSettledDocument {
3721
+ export type AsObject = {
3722
+ documentTypeName: string,
3723
+ documentId: Uint8Array | string,
3724
+ documentLastModifiedAt: number,
3725
+ documentRevision: number,
3726
+ reason?: ContractModerationReason.AsObject,
3727
+ }
3728
+ }
3729
+
3730
+ export class ContractTeamAction extends jspb.Message {
3731
+ getActionId(): Uint8Array | string;
3732
+ getActionId_asU8(): Uint8Array;
3733
+ getActionId_asB64(): string;
3734
+ setActionId(value: Uint8Array | string): void;
3735
+
3736
+ getProposerId(): Uint8Array | string;
3737
+ getProposerId_asU8(): Uint8Array;
3738
+ getProposerId_asB64(): string;
3739
+ setProposerId(value: Uint8Array | string): void;
3740
+
3741
+ getProposedAt(): number;
3742
+ setProposedAt(value: number): void;
3743
+
3744
+ hasDeleteSettledDocument(): boolean;
3745
+ clearDeleteSettledDocument(): void;
3746
+ getDeleteSettledDocument(): GetContractTeamActionsResponse.DeleteSettledDocument | undefined;
3747
+ setDeleteSettledDocument(value?: GetContractTeamActionsResponse.DeleteSettledDocument): void;
3748
+
3749
+ getApprovalCount(): number;
3750
+ setApprovalCount(value: number): void;
3751
+
3752
+ getEventCase(): ContractTeamAction.EventCase;
3753
+ serializeBinary(): Uint8Array;
3754
+ toObject(includeInstance?: boolean): ContractTeamAction.AsObject;
3755
+ static toObject(includeInstance: boolean, msg: ContractTeamAction): ContractTeamAction.AsObject;
3756
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3757
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3758
+ static serializeBinaryToWriter(message: ContractTeamAction, writer: jspb.BinaryWriter): void;
3759
+ static deserializeBinary(bytes: Uint8Array): ContractTeamAction;
3760
+ static deserializeBinaryFromReader(message: ContractTeamAction, reader: jspb.BinaryReader): ContractTeamAction;
3761
+ }
3762
+
3763
+ export namespace ContractTeamAction {
3764
+ export type AsObject = {
3765
+ actionId: Uint8Array | string,
3766
+ proposerId: Uint8Array | string,
3767
+ proposedAt: number,
3768
+ deleteSettledDocument?: GetContractTeamActionsResponse.DeleteSettledDocument.AsObject,
3769
+ approvalCount: number,
3770
+ }
3771
+
3772
+ export enum EventCase {
3773
+ EVENT_NOT_SET = 0,
3774
+ DELETE_SETTLED_DOCUMENT = 4,
3775
+ }
3776
+ }
3777
+
3778
+ export class ContractTeamActions extends jspb.Message {
3779
+ clearActionsList(): void;
3780
+ getActionsList(): Array<GetContractTeamActionsResponse.ContractTeamAction>;
3781
+ setActionsList(value: Array<GetContractTeamActionsResponse.ContractTeamAction>): void;
3782
+ addActions(value?: GetContractTeamActionsResponse.ContractTeamAction, index?: number): GetContractTeamActionsResponse.ContractTeamAction;
3783
+
3784
+ serializeBinary(): Uint8Array;
3785
+ toObject(includeInstance?: boolean): ContractTeamActions.AsObject;
3786
+ static toObject(includeInstance: boolean, msg: ContractTeamActions): ContractTeamActions.AsObject;
3787
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3788
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3789
+ static serializeBinaryToWriter(message: ContractTeamActions, writer: jspb.BinaryWriter): void;
3790
+ static deserializeBinary(bytes: Uint8Array): ContractTeamActions;
3791
+ static deserializeBinaryFromReader(message: ContractTeamActions, reader: jspb.BinaryReader): ContractTeamActions;
3792
+ }
3793
+
3794
+ export namespace ContractTeamActions {
3795
+ export type AsObject = {
3796
+ actionsList: Array<GetContractTeamActionsResponse.ContractTeamAction.AsObject>,
3797
+ }
3798
+ }
3799
+
3800
+ export class GetContractTeamActionsResponseV0 extends jspb.Message {
3801
+ hasActions(): boolean;
3802
+ clearActions(): void;
3803
+ getActions(): GetContractTeamActionsResponse.ContractTeamActions | undefined;
3804
+ setActions(value?: GetContractTeamActionsResponse.ContractTeamActions): void;
3805
+
3806
+ hasProof(): boolean;
3807
+ clearProof(): void;
3808
+ getProof(): Proof | undefined;
3809
+ setProof(value?: Proof): void;
3810
+
3811
+ hasMetadata(): boolean;
3812
+ clearMetadata(): void;
3813
+ getMetadata(): ResponseMetadata | undefined;
3814
+ setMetadata(value?: ResponseMetadata): void;
3815
+
3816
+ getResultCase(): GetContractTeamActionsResponseV0.ResultCase;
3817
+ serializeBinary(): Uint8Array;
3818
+ toObject(includeInstance?: boolean): GetContractTeamActionsResponseV0.AsObject;
3819
+ static toObject(includeInstance: boolean, msg: GetContractTeamActionsResponseV0): GetContractTeamActionsResponseV0.AsObject;
3820
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3821
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3822
+ static serializeBinaryToWriter(message: GetContractTeamActionsResponseV0, writer: jspb.BinaryWriter): void;
3823
+ static deserializeBinary(bytes: Uint8Array): GetContractTeamActionsResponseV0;
3824
+ static deserializeBinaryFromReader(message: GetContractTeamActionsResponseV0, reader: jspb.BinaryReader): GetContractTeamActionsResponseV0;
3825
+ }
3826
+
3827
+ export namespace GetContractTeamActionsResponseV0 {
3828
+ export type AsObject = {
3829
+ actions?: GetContractTeamActionsResponse.ContractTeamActions.AsObject,
3830
+ proof?: Proof.AsObject,
3831
+ metadata?: ResponseMetadata.AsObject,
3832
+ }
3833
+
3834
+ export enum ResultCase {
3835
+ RESULT_NOT_SET = 0,
3836
+ ACTIONS = 1,
3837
+ PROOF = 2,
3838
+ }
3839
+ }
3840
+
3841
+ export enum VersionCase {
3842
+ VERSION_NOT_SET = 0,
3843
+ V0 = 1,
3844
+ }
3845
+ }
3846
+
3847
+ export class GetContractTeamActionSignersRequest extends jspb.Message {
3848
+ hasV0(): boolean;
3849
+ clearV0(): void;
3850
+ getV0(): GetContractTeamActionSignersRequest.GetContractTeamActionSignersRequestV0 | undefined;
3851
+ setV0(value?: GetContractTeamActionSignersRequest.GetContractTeamActionSignersRequestV0): void;
3852
+
3853
+ getVersionCase(): GetContractTeamActionSignersRequest.VersionCase;
3854
+ serializeBinary(): Uint8Array;
3855
+ toObject(includeInstance?: boolean): GetContractTeamActionSignersRequest.AsObject;
3856
+ static toObject(includeInstance: boolean, msg: GetContractTeamActionSignersRequest): GetContractTeamActionSignersRequest.AsObject;
3857
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3858
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3859
+ static serializeBinaryToWriter(message: GetContractTeamActionSignersRequest, writer: jspb.BinaryWriter): void;
3860
+ static deserializeBinary(bytes: Uint8Array): GetContractTeamActionSignersRequest;
3861
+ static deserializeBinaryFromReader(message: GetContractTeamActionSignersRequest, reader: jspb.BinaryReader): GetContractTeamActionSignersRequest;
3862
+ }
3863
+
3864
+ export namespace GetContractTeamActionSignersRequest {
3865
+ export type AsObject = {
3866
+ v0?: GetContractTeamActionSignersRequest.GetContractTeamActionSignersRequestV0.AsObject,
3867
+ }
3868
+
3869
+ export class GetContractTeamActionSignersRequestV0 extends jspb.Message {
3870
+ getContractId(): Uint8Array | string;
3871
+ getContractId_asU8(): Uint8Array;
3872
+ getContractId_asB64(): string;
3873
+ setContractId(value: Uint8Array | string): void;
3874
+
3875
+ getStatus(): GetContractTeamActionSignersRequest.ActionStatusMap[keyof GetContractTeamActionSignersRequest.ActionStatusMap];
3876
+ setStatus(value: GetContractTeamActionSignersRequest.ActionStatusMap[keyof GetContractTeamActionSignersRequest.ActionStatusMap]): void;
3877
+
3878
+ getActionId(): Uint8Array | string;
3879
+ getActionId_asU8(): Uint8Array;
3880
+ getActionId_asB64(): string;
3881
+ setActionId(value: Uint8Array | string): void;
3882
+
3883
+ getProve(): boolean;
3884
+ setProve(value: boolean): void;
3885
+
3886
+ serializeBinary(): Uint8Array;
3887
+ toObject(includeInstance?: boolean): GetContractTeamActionSignersRequestV0.AsObject;
3888
+ static toObject(includeInstance: boolean, msg: GetContractTeamActionSignersRequestV0): GetContractTeamActionSignersRequestV0.AsObject;
3889
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3890
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3891
+ static serializeBinaryToWriter(message: GetContractTeamActionSignersRequestV0, writer: jspb.BinaryWriter): void;
3892
+ static deserializeBinary(bytes: Uint8Array): GetContractTeamActionSignersRequestV0;
3893
+ static deserializeBinaryFromReader(message: GetContractTeamActionSignersRequestV0, reader: jspb.BinaryReader): GetContractTeamActionSignersRequestV0;
3894
+ }
3895
+
3896
+ export namespace GetContractTeamActionSignersRequestV0 {
3897
+ export type AsObject = {
3898
+ contractId: Uint8Array | string,
3899
+ status: GetContractTeamActionSignersRequest.ActionStatusMap[keyof GetContractTeamActionSignersRequest.ActionStatusMap],
3900
+ actionId: Uint8Array | string,
3901
+ prove: boolean,
3902
+ }
3903
+ }
3904
+
3905
+ export interface ActionStatusMap {
3906
+ ACTIVE: 0;
3907
+ CLOSED: 1;
3908
+ }
3909
+
3910
+ export const ActionStatus: ActionStatusMap;
3911
+
3912
+ export enum VersionCase {
3913
+ VERSION_NOT_SET = 0,
3914
+ V0 = 1,
3915
+ }
3916
+ }
3917
+
3918
+ export class GetContractTeamActionSignersResponse extends jspb.Message {
3919
+ hasV0(): boolean;
3920
+ clearV0(): void;
3921
+ getV0(): GetContractTeamActionSignersResponse.GetContractTeamActionSignersResponseV0 | undefined;
3922
+ setV0(value?: GetContractTeamActionSignersResponse.GetContractTeamActionSignersResponseV0): void;
3923
+
3924
+ getVersionCase(): GetContractTeamActionSignersResponse.VersionCase;
3925
+ serializeBinary(): Uint8Array;
3926
+ toObject(includeInstance?: boolean): GetContractTeamActionSignersResponse.AsObject;
3927
+ static toObject(includeInstance: boolean, msg: GetContractTeamActionSignersResponse): GetContractTeamActionSignersResponse.AsObject;
3928
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3929
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3930
+ static serializeBinaryToWriter(message: GetContractTeamActionSignersResponse, writer: jspb.BinaryWriter): void;
3931
+ static deserializeBinary(bytes: Uint8Array): GetContractTeamActionSignersResponse;
3932
+ static deserializeBinaryFromReader(message: GetContractTeamActionSignersResponse, reader: jspb.BinaryReader): GetContractTeamActionSignersResponse;
3933
+ }
3934
+
3935
+ export namespace GetContractTeamActionSignersResponse {
3936
+ export type AsObject = {
3937
+ v0?: GetContractTeamActionSignersResponse.GetContractTeamActionSignersResponseV0.AsObject,
3938
+ }
3939
+
3940
+ export class ContractTeamActionSigners extends jspb.Message {
3941
+ clearSignerIdsList(): void;
3942
+ getSignerIdsList(): Array<Uint8Array | string>;
3943
+ getSignerIdsList_asU8(): Array<Uint8Array>;
3944
+ getSignerIdsList_asB64(): Array<string>;
3945
+ setSignerIdsList(value: Array<Uint8Array | string>): void;
3946
+ addSignerIds(value: Uint8Array | string, index?: number): Uint8Array | string;
3947
+
3948
+ serializeBinary(): Uint8Array;
3949
+ toObject(includeInstance?: boolean): ContractTeamActionSigners.AsObject;
3950
+ static toObject(includeInstance: boolean, msg: ContractTeamActionSigners): ContractTeamActionSigners.AsObject;
3951
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3952
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3953
+ static serializeBinaryToWriter(message: ContractTeamActionSigners, writer: jspb.BinaryWriter): void;
3954
+ static deserializeBinary(bytes: Uint8Array): ContractTeamActionSigners;
3955
+ static deserializeBinaryFromReader(message: ContractTeamActionSigners, reader: jspb.BinaryReader): ContractTeamActionSigners;
3956
+ }
3957
+
3958
+ export namespace ContractTeamActionSigners {
3959
+ export type AsObject = {
3960
+ signerIdsList: Array<Uint8Array | string>,
3961
+ }
3962
+ }
3963
+
3964
+ export class GetContractTeamActionSignersResponseV0 extends jspb.Message {
3965
+ hasSigners(): boolean;
3966
+ clearSigners(): void;
3967
+ getSigners(): GetContractTeamActionSignersResponse.ContractTeamActionSigners | undefined;
3968
+ setSigners(value?: GetContractTeamActionSignersResponse.ContractTeamActionSigners): void;
3969
+
3970
+ hasProof(): boolean;
3971
+ clearProof(): void;
3972
+ getProof(): Proof | undefined;
3973
+ setProof(value?: Proof): void;
3974
+
3975
+ hasMetadata(): boolean;
3976
+ clearMetadata(): void;
3977
+ getMetadata(): ResponseMetadata | undefined;
3978
+ setMetadata(value?: ResponseMetadata): void;
3979
+
3980
+ getResultCase(): GetContractTeamActionSignersResponseV0.ResultCase;
3981
+ serializeBinary(): Uint8Array;
3982
+ toObject(includeInstance?: boolean): GetContractTeamActionSignersResponseV0.AsObject;
3983
+ static toObject(includeInstance: boolean, msg: GetContractTeamActionSignersResponseV0): GetContractTeamActionSignersResponseV0.AsObject;
3984
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
3985
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
3986
+ static serializeBinaryToWriter(message: GetContractTeamActionSignersResponseV0, writer: jspb.BinaryWriter): void;
3987
+ static deserializeBinary(bytes: Uint8Array): GetContractTeamActionSignersResponseV0;
3988
+ static deserializeBinaryFromReader(message: GetContractTeamActionSignersResponseV0, reader: jspb.BinaryReader): GetContractTeamActionSignersResponseV0;
3989
+ }
3990
+
3991
+ export namespace GetContractTeamActionSignersResponseV0 {
3992
+ export type AsObject = {
3993
+ signers?: GetContractTeamActionSignersResponse.ContractTeamActionSigners.AsObject,
3994
+ proof?: Proof.AsObject,
3995
+ metadata?: ResponseMetadata.AsObject,
3996
+ }
3997
+
3998
+ export enum ResultCase {
3999
+ RESULT_NOT_SET = 0,
4000
+ SIGNERS = 1,
4001
+ PROOF = 2,
4002
+ }
4003
+ }
4004
+
4005
+ export enum VersionCase {
4006
+ VERSION_NOT_SET = 0,
4007
+ V0 = 1,
4008
+ }
4009
+ }
4010
+
4011
+ export class GetContractModerationActionCountsRequest extends jspb.Message {
4012
+ hasV0(): boolean;
4013
+ clearV0(): void;
4014
+ getV0(): GetContractModerationActionCountsRequest.GetContractModerationActionCountsRequestV0 | undefined;
4015
+ setV0(value?: GetContractModerationActionCountsRequest.GetContractModerationActionCountsRequestV0): void;
4016
+
4017
+ getVersionCase(): GetContractModerationActionCountsRequest.VersionCase;
4018
+ serializeBinary(): Uint8Array;
4019
+ toObject(includeInstance?: boolean): GetContractModerationActionCountsRequest.AsObject;
4020
+ static toObject(includeInstance: boolean, msg: GetContractModerationActionCountsRequest): GetContractModerationActionCountsRequest.AsObject;
4021
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4022
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4023
+ static serializeBinaryToWriter(message: GetContractModerationActionCountsRequest, writer: jspb.BinaryWriter): void;
4024
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationActionCountsRequest;
4025
+ static deserializeBinaryFromReader(message: GetContractModerationActionCountsRequest, reader: jspb.BinaryReader): GetContractModerationActionCountsRequest;
4026
+ }
4027
+
4028
+ export namespace GetContractModerationActionCountsRequest {
4029
+ export type AsObject = {
4030
+ v0?: GetContractModerationActionCountsRequest.GetContractModerationActionCountsRequestV0.AsObject,
4031
+ }
4032
+
4033
+ export class GetContractModerationActionCountsRequestV0 extends jspb.Message {
4034
+ getContractId(): Uint8Array | string;
4035
+ getContractId_asU8(): Uint8Array;
4036
+ getContractId_asB64(): string;
4037
+ setContractId(value: Uint8Array | string): void;
4038
+
4039
+ getProve(): boolean;
4040
+ setProve(value: boolean): void;
4041
+
4042
+ serializeBinary(): Uint8Array;
4043
+ toObject(includeInstance?: boolean): GetContractModerationActionCountsRequestV0.AsObject;
4044
+ static toObject(includeInstance: boolean, msg: GetContractModerationActionCountsRequestV0): GetContractModerationActionCountsRequestV0.AsObject;
4045
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4046
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4047
+ static serializeBinaryToWriter(message: GetContractModerationActionCountsRequestV0, writer: jspb.BinaryWriter): void;
4048
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationActionCountsRequestV0;
4049
+ static deserializeBinaryFromReader(message: GetContractModerationActionCountsRequestV0, reader: jspb.BinaryReader): GetContractModerationActionCountsRequestV0;
4050
+ }
4051
+
4052
+ export namespace GetContractModerationActionCountsRequestV0 {
4053
+ export type AsObject = {
4054
+ contractId: Uint8Array | string,
4055
+ prove: boolean,
4056
+ }
4057
+ }
4058
+
4059
+ export enum VersionCase {
4060
+ VERSION_NOT_SET = 0,
4061
+ V0 = 1,
4062
+ }
4063
+ }
4064
+
4065
+ export class GetContractModerationActionCountsResponse extends jspb.Message {
4066
+ hasV0(): boolean;
4067
+ clearV0(): void;
4068
+ getV0(): GetContractModerationActionCountsResponse.GetContractModerationActionCountsResponseV0 | undefined;
4069
+ setV0(value?: GetContractModerationActionCountsResponse.GetContractModerationActionCountsResponseV0): void;
4070
+
4071
+ getVersionCase(): GetContractModerationActionCountsResponse.VersionCase;
4072
+ serializeBinary(): Uint8Array;
4073
+ toObject(includeInstance?: boolean): GetContractModerationActionCountsResponse.AsObject;
4074
+ static toObject(includeInstance: boolean, msg: GetContractModerationActionCountsResponse): GetContractModerationActionCountsResponse.AsObject;
4075
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4076
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4077
+ static serializeBinaryToWriter(message: GetContractModerationActionCountsResponse, writer: jspb.BinaryWriter): void;
4078
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationActionCountsResponse;
4079
+ static deserializeBinaryFromReader(message: GetContractModerationActionCountsResponse, reader: jspb.BinaryReader): GetContractModerationActionCountsResponse;
4080
+ }
4081
+
4082
+ export namespace GetContractModerationActionCountsResponse {
4083
+ export type AsObject = {
4084
+ v0?: GetContractModerationActionCountsResponse.GetContractModerationActionCountsResponseV0.AsObject,
4085
+ }
4086
+
4087
+ export class ContractModerationActionCount extends jspb.Message {
4088
+ getIdentityId(): Uint8Array | string;
4089
+ getIdentityId_asU8(): Uint8Array;
4090
+ getIdentityId_asB64(): string;
4091
+ setIdentityId(value: Uint8Array | string): void;
4092
+
4093
+ getCount(): number;
4094
+ setCount(value: number): void;
4095
+
4096
+ serializeBinary(): Uint8Array;
4097
+ toObject(includeInstance?: boolean): ContractModerationActionCount.AsObject;
4098
+ static toObject(includeInstance: boolean, msg: ContractModerationActionCount): ContractModerationActionCount.AsObject;
4099
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4100
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4101
+ static serializeBinaryToWriter(message: ContractModerationActionCount, writer: jspb.BinaryWriter): void;
4102
+ static deserializeBinary(bytes: Uint8Array): ContractModerationActionCount;
4103
+ static deserializeBinaryFromReader(message: ContractModerationActionCount, reader: jspb.BinaryReader): ContractModerationActionCount;
4104
+ }
4105
+
4106
+ export namespace ContractModerationActionCount {
4107
+ export type AsObject = {
4108
+ identityId: Uint8Array | string,
4109
+ count: number,
4110
+ }
4111
+ }
4112
+
4113
+ export class ContractModerationActionCounts extends jspb.Message {
4114
+ clearCountsList(): void;
4115
+ getCountsList(): Array<GetContractModerationActionCountsResponse.ContractModerationActionCount>;
4116
+ setCountsList(value: Array<GetContractModerationActionCountsResponse.ContractModerationActionCount>): void;
4117
+ addCounts(value?: GetContractModerationActionCountsResponse.ContractModerationActionCount, index?: number): GetContractModerationActionCountsResponse.ContractModerationActionCount;
4118
+
4119
+ serializeBinary(): Uint8Array;
4120
+ toObject(includeInstance?: boolean): ContractModerationActionCounts.AsObject;
4121
+ static toObject(includeInstance: boolean, msg: ContractModerationActionCounts): ContractModerationActionCounts.AsObject;
4122
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4123
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4124
+ static serializeBinaryToWriter(message: ContractModerationActionCounts, writer: jspb.BinaryWriter): void;
4125
+ static deserializeBinary(bytes: Uint8Array): ContractModerationActionCounts;
4126
+ static deserializeBinaryFromReader(message: ContractModerationActionCounts, reader: jspb.BinaryReader): ContractModerationActionCounts;
4127
+ }
4128
+
4129
+ export namespace ContractModerationActionCounts {
4130
+ export type AsObject = {
4131
+ countsList: Array<GetContractModerationActionCountsResponse.ContractModerationActionCount.AsObject>,
4132
+ }
4133
+ }
4134
+
4135
+ export class GetContractModerationActionCountsResponseV0 extends jspb.Message {
4136
+ hasCounts(): boolean;
4137
+ clearCounts(): void;
4138
+ getCounts(): GetContractModerationActionCountsResponse.ContractModerationActionCounts | undefined;
4139
+ setCounts(value?: GetContractModerationActionCountsResponse.ContractModerationActionCounts): void;
4140
+
4141
+ hasProof(): boolean;
4142
+ clearProof(): void;
4143
+ getProof(): Proof | undefined;
4144
+ setProof(value?: Proof): void;
4145
+
4146
+ hasMetadata(): boolean;
4147
+ clearMetadata(): void;
4148
+ getMetadata(): ResponseMetadata | undefined;
4149
+ setMetadata(value?: ResponseMetadata): void;
4150
+
4151
+ getResultCase(): GetContractModerationActionCountsResponseV0.ResultCase;
4152
+ serializeBinary(): Uint8Array;
4153
+ toObject(includeInstance?: boolean): GetContractModerationActionCountsResponseV0.AsObject;
4154
+ static toObject(includeInstance: boolean, msg: GetContractModerationActionCountsResponseV0): GetContractModerationActionCountsResponseV0.AsObject;
4155
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4156
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4157
+ static serializeBinaryToWriter(message: GetContractModerationActionCountsResponseV0, writer: jspb.BinaryWriter): void;
4158
+ static deserializeBinary(bytes: Uint8Array): GetContractModerationActionCountsResponseV0;
4159
+ static deserializeBinaryFromReader(message: GetContractModerationActionCountsResponseV0, reader: jspb.BinaryReader): GetContractModerationActionCountsResponseV0;
4160
+ }
4161
+
4162
+ export namespace GetContractModerationActionCountsResponseV0 {
4163
+ export type AsObject = {
4164
+ counts?: GetContractModerationActionCountsResponse.ContractModerationActionCounts.AsObject,
4165
+ proof?: Proof.AsObject,
4166
+ metadata?: ResponseMetadata.AsObject,
4167
+ }
4168
+
4169
+ export enum ResultCase {
4170
+ RESULT_NOT_SET = 0,
4171
+ COUNTS = 1,
4172
+ PROOF = 2,
4173
+ }
4174
+ }
4175
+
4176
+ export enum VersionCase {
4177
+ VERSION_NOT_SET = 0,
4178
+ V0 = 1,
4179
+ }
4180
+ }
4181
+
4182
+ export class GetContractFeePotsRequest extends jspb.Message {
4183
+ hasV0(): boolean;
4184
+ clearV0(): void;
4185
+ getV0(): GetContractFeePotsRequest.GetContractFeePotsRequestV0 | undefined;
4186
+ setV0(value?: GetContractFeePotsRequest.GetContractFeePotsRequestV0): void;
4187
+
4188
+ getVersionCase(): GetContractFeePotsRequest.VersionCase;
4189
+ serializeBinary(): Uint8Array;
4190
+ toObject(includeInstance?: boolean): GetContractFeePotsRequest.AsObject;
4191
+ static toObject(includeInstance: boolean, msg: GetContractFeePotsRequest): GetContractFeePotsRequest.AsObject;
4192
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4193
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4194
+ static serializeBinaryToWriter(message: GetContractFeePotsRequest, writer: jspb.BinaryWriter): void;
4195
+ static deserializeBinary(bytes: Uint8Array): GetContractFeePotsRequest;
4196
+ static deserializeBinaryFromReader(message: GetContractFeePotsRequest, reader: jspb.BinaryReader): GetContractFeePotsRequest;
4197
+ }
4198
+
4199
+ export namespace GetContractFeePotsRequest {
4200
+ export type AsObject = {
4201
+ v0?: GetContractFeePotsRequest.GetContractFeePotsRequestV0.AsObject,
4202
+ }
4203
+
4204
+ export class GetContractFeePotsRequestV0 extends jspb.Message {
4205
+ getContractId(): Uint8Array | string;
4206
+ getContractId_asU8(): Uint8Array;
4207
+ getContractId_asB64(): string;
4208
+ setContractId(value: Uint8Array | string): void;
4209
+
4210
+ getProve(): boolean;
4211
+ setProve(value: boolean): void;
4212
+
4213
+ serializeBinary(): Uint8Array;
4214
+ toObject(includeInstance?: boolean): GetContractFeePotsRequestV0.AsObject;
4215
+ static toObject(includeInstance: boolean, msg: GetContractFeePotsRequestV0): GetContractFeePotsRequestV0.AsObject;
4216
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4217
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4218
+ static serializeBinaryToWriter(message: GetContractFeePotsRequestV0, writer: jspb.BinaryWriter): void;
4219
+ static deserializeBinary(bytes: Uint8Array): GetContractFeePotsRequestV0;
4220
+ static deserializeBinaryFromReader(message: GetContractFeePotsRequestV0, reader: jspb.BinaryReader): GetContractFeePotsRequestV0;
4221
+ }
4222
+
4223
+ export namespace GetContractFeePotsRequestV0 {
4224
+ export type AsObject = {
4225
+ contractId: Uint8Array | string,
4226
+ prove: boolean,
4227
+ }
4228
+ }
4229
+
4230
+ export enum VersionCase {
4231
+ VERSION_NOT_SET = 0,
4232
+ V0 = 1,
4233
+ }
4234
+ }
4235
+
4236
+ export class GetContractFeePotsResponse extends jspb.Message {
4237
+ hasV0(): boolean;
4238
+ clearV0(): void;
4239
+ getV0(): GetContractFeePotsResponse.GetContractFeePotsResponseV0 | undefined;
4240
+ setV0(value?: GetContractFeePotsResponse.GetContractFeePotsResponseV0): void;
4241
+
4242
+ getVersionCase(): GetContractFeePotsResponse.VersionCase;
4243
+ serializeBinary(): Uint8Array;
4244
+ toObject(includeInstance?: boolean): GetContractFeePotsResponse.AsObject;
4245
+ static toObject(includeInstance: boolean, msg: GetContractFeePotsResponse): GetContractFeePotsResponse.AsObject;
4246
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4247
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4248
+ static serializeBinaryToWriter(message: GetContractFeePotsResponse, writer: jspb.BinaryWriter): void;
4249
+ static deserializeBinary(bytes: Uint8Array): GetContractFeePotsResponse;
4250
+ static deserializeBinaryFromReader(message: GetContractFeePotsResponse, reader: jspb.BinaryReader): GetContractFeePotsResponse;
4251
+ }
4252
+
4253
+ export namespace GetContractFeePotsResponse {
4254
+ export type AsObject = {
4255
+ v0?: GetContractFeePotsResponse.GetContractFeePotsResponseV0.AsObject,
4256
+ }
4257
+
4258
+ export class ContractFeePotLastClaim extends jspb.Message {
4259
+ getEpoch(): number;
4260
+ setEpoch(value: number): void;
4261
+
4262
+ getTimeMs(): string;
4263
+ setTimeMs(value: string): void;
4264
+
4265
+ getClaimantId(): Uint8Array | string;
4266
+ getClaimantId_asU8(): Uint8Array;
4267
+ getClaimantId_asB64(): string;
4268
+ setClaimantId(value: Uint8Array | string): void;
4269
+
4270
+ serializeBinary(): Uint8Array;
4271
+ toObject(includeInstance?: boolean): ContractFeePotLastClaim.AsObject;
4272
+ static toObject(includeInstance: boolean, msg: ContractFeePotLastClaim): ContractFeePotLastClaim.AsObject;
4273
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4274
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4275
+ static serializeBinaryToWriter(message: ContractFeePotLastClaim, writer: jspb.BinaryWriter): void;
4276
+ static deserializeBinary(bytes: Uint8Array): ContractFeePotLastClaim;
4277
+ static deserializeBinaryFromReader(message: ContractFeePotLastClaim, reader: jspb.BinaryReader): ContractFeePotLastClaim;
4278
+ }
4279
+
4280
+ export namespace ContractFeePotLastClaim {
4281
+ export type AsObject = {
4282
+ epoch: number,
4283
+ timeMs: string,
4284
+ claimantId: Uint8Array | string,
4285
+ }
4286
+ }
4287
+
4288
+ export class ContractFeePot extends jspb.Message {
4289
+ getCredits(): string;
4290
+ setCredits(value: string): void;
4291
+
4292
+ hasLastClaim(): boolean;
4293
+ clearLastClaim(): void;
4294
+ getLastClaim(): GetContractFeePotsResponse.ContractFeePotLastClaim | undefined;
4295
+ setLastClaim(value?: GetContractFeePotsResponse.ContractFeePotLastClaim): void;
4296
+
4297
+ serializeBinary(): Uint8Array;
4298
+ toObject(includeInstance?: boolean): ContractFeePot.AsObject;
4299
+ static toObject(includeInstance: boolean, msg: ContractFeePot): ContractFeePot.AsObject;
4300
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4301
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4302
+ static serializeBinaryToWriter(message: ContractFeePot, writer: jspb.BinaryWriter): void;
4303
+ static deserializeBinary(bytes: Uint8Array): ContractFeePot;
4304
+ static deserializeBinaryFromReader(message: ContractFeePot, reader: jspb.BinaryReader): ContractFeePot;
4305
+ }
4306
+
4307
+ export namespace ContractFeePot {
4308
+ export type AsObject = {
4309
+ credits: string,
4310
+ lastClaim?: GetContractFeePotsResponse.ContractFeePotLastClaim.AsObject,
4311
+ }
4312
+ }
4313
+
4314
+ export class ContractFeePots extends jspb.Message {
4315
+ hasOwner(): boolean;
4316
+ clearOwner(): void;
4317
+ getOwner(): GetContractFeePotsResponse.ContractFeePot | undefined;
4318
+ setOwner(value?: GetContractFeePotsResponse.ContractFeePot): void;
4319
+
4320
+ hasModerators(): boolean;
4321
+ clearModerators(): void;
4322
+ getModerators(): GetContractFeePotsResponse.ContractFeePot | undefined;
4323
+ setModerators(value?: GetContractFeePotsResponse.ContractFeePot): void;
4324
+
4325
+ serializeBinary(): Uint8Array;
4326
+ toObject(includeInstance?: boolean): ContractFeePots.AsObject;
4327
+ static toObject(includeInstance: boolean, msg: ContractFeePots): ContractFeePots.AsObject;
4328
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4329
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4330
+ static serializeBinaryToWriter(message: ContractFeePots, writer: jspb.BinaryWriter): void;
4331
+ static deserializeBinary(bytes: Uint8Array): ContractFeePots;
4332
+ static deserializeBinaryFromReader(message: ContractFeePots, reader: jspb.BinaryReader): ContractFeePots;
4333
+ }
4334
+
4335
+ export namespace ContractFeePots {
4336
+ export type AsObject = {
4337
+ owner?: GetContractFeePotsResponse.ContractFeePot.AsObject,
4338
+ moderators?: GetContractFeePotsResponse.ContractFeePot.AsObject,
4339
+ }
4340
+ }
4341
+
4342
+ export class GetContractFeePotsResponseV0 extends jspb.Message {
4343
+ hasPots(): boolean;
4344
+ clearPots(): void;
4345
+ getPots(): GetContractFeePotsResponse.ContractFeePots | undefined;
4346
+ setPots(value?: GetContractFeePotsResponse.ContractFeePots): void;
4347
+
4348
+ hasProof(): boolean;
4349
+ clearProof(): void;
4350
+ getProof(): Proof | undefined;
4351
+ setProof(value?: Proof): void;
4352
+
4353
+ hasMetadata(): boolean;
4354
+ clearMetadata(): void;
4355
+ getMetadata(): ResponseMetadata | undefined;
4356
+ setMetadata(value?: ResponseMetadata): void;
4357
+
4358
+ getResultCase(): GetContractFeePotsResponseV0.ResultCase;
4359
+ serializeBinary(): Uint8Array;
4360
+ toObject(includeInstance?: boolean): GetContractFeePotsResponseV0.AsObject;
4361
+ static toObject(includeInstance: boolean, msg: GetContractFeePotsResponseV0): GetContractFeePotsResponseV0.AsObject;
4362
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4363
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4364
+ static serializeBinaryToWriter(message: GetContractFeePotsResponseV0, writer: jspb.BinaryWriter): void;
4365
+ static deserializeBinary(bytes: Uint8Array): GetContractFeePotsResponseV0;
4366
+ static deserializeBinaryFromReader(message: GetContractFeePotsResponseV0, reader: jspb.BinaryReader): GetContractFeePotsResponseV0;
4367
+ }
4368
+
4369
+ export namespace GetContractFeePotsResponseV0 {
4370
+ export type AsObject = {
4371
+ pots?: GetContractFeePotsResponse.ContractFeePots.AsObject,
4372
+ proof?: Proof.AsObject,
4373
+ metadata?: ResponseMetadata.AsObject,
4374
+ }
4375
+
4376
+ export enum ResultCase {
4377
+ RESULT_NOT_SET = 0,
4378
+ POTS = 1,
4379
+ PROOF = 2,
4380
+ }
4381
+ }
4382
+
4383
+ export enum VersionCase {
4384
+ VERSION_NOT_SET = 0,
4385
+ V0 = 1,
4386
+ }
4387
+ }
4388
+
4389
+ export class GetContractGroupsForContractRequest extends jspb.Message {
4390
+ hasV0(): boolean;
4391
+ clearV0(): void;
4392
+ getV0(): GetContractGroupsForContractRequest.GetContractGroupsForContractRequestV0 | undefined;
4393
+ setV0(value?: GetContractGroupsForContractRequest.GetContractGroupsForContractRequestV0): void;
4394
+
4395
+ getVersionCase(): GetContractGroupsForContractRequest.VersionCase;
4396
+ serializeBinary(): Uint8Array;
4397
+ toObject(includeInstance?: boolean): GetContractGroupsForContractRequest.AsObject;
4398
+ static toObject(includeInstance: boolean, msg: GetContractGroupsForContractRequest): GetContractGroupsForContractRequest.AsObject;
4399
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4400
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4401
+ static serializeBinaryToWriter(message: GetContractGroupsForContractRequest, writer: jspb.BinaryWriter): void;
4402
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupsForContractRequest;
4403
+ static deserializeBinaryFromReader(message: GetContractGroupsForContractRequest, reader: jspb.BinaryReader): GetContractGroupsForContractRequest;
4404
+ }
4405
+
4406
+ export namespace GetContractGroupsForContractRequest {
4407
+ export type AsObject = {
4408
+ v0?: GetContractGroupsForContractRequest.GetContractGroupsForContractRequestV0.AsObject,
4409
+ }
4410
+
4411
+ export class GetContractGroupsForContractRequestV0 extends jspb.Message {
4412
+ getContractId(): Uint8Array | string;
4413
+ getContractId_asU8(): Uint8Array;
4414
+ getContractId_asB64(): string;
4415
+ setContractId(value: Uint8Array | string): void;
4416
+
4417
+ getProve(): boolean;
4418
+ setProve(value: boolean): void;
4419
+
4420
+ serializeBinary(): Uint8Array;
4421
+ toObject(includeInstance?: boolean): GetContractGroupsForContractRequestV0.AsObject;
4422
+ static toObject(includeInstance: boolean, msg: GetContractGroupsForContractRequestV0): GetContractGroupsForContractRequestV0.AsObject;
4423
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4424
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4425
+ static serializeBinaryToWriter(message: GetContractGroupsForContractRequestV0, writer: jspb.BinaryWriter): void;
4426
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupsForContractRequestV0;
4427
+ static deserializeBinaryFromReader(message: GetContractGroupsForContractRequestV0, reader: jspb.BinaryReader): GetContractGroupsForContractRequestV0;
4428
+ }
4429
+
4430
+ export namespace GetContractGroupsForContractRequestV0 {
4431
+ export type AsObject = {
4432
+ contractId: Uint8Array | string,
4433
+ prove: boolean,
4434
+ }
4435
+ }
4436
+
4437
+ export enum VersionCase {
4438
+ VERSION_NOT_SET = 0,
4439
+ V0 = 1,
4440
+ }
4441
+ }
4442
+
4443
+ export class GetContractGroupsForContractResponse extends jspb.Message {
4444
+ hasV0(): boolean;
4445
+ clearV0(): void;
4446
+ getV0(): GetContractGroupsForContractResponse.GetContractGroupsForContractResponseV0 | undefined;
4447
+ setV0(value?: GetContractGroupsForContractResponse.GetContractGroupsForContractResponseV0): void;
4448
+
4449
+ getVersionCase(): GetContractGroupsForContractResponse.VersionCase;
4450
+ serializeBinary(): Uint8Array;
4451
+ toObject(includeInstance?: boolean): GetContractGroupsForContractResponse.AsObject;
4452
+ static toObject(includeInstance: boolean, msg: GetContractGroupsForContractResponse): GetContractGroupsForContractResponse.AsObject;
4453
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4454
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4455
+ static serializeBinaryToWriter(message: GetContractGroupsForContractResponse, writer: jspb.BinaryWriter): void;
4456
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupsForContractResponse;
4457
+ static deserializeBinaryFromReader(message: GetContractGroupsForContractResponse, reader: jspb.BinaryReader): GetContractGroupsForContractResponse;
4458
+ }
4459
+
4460
+ export namespace GetContractGroupsForContractResponse {
4461
+ export type AsObject = {
4462
+ v0?: GetContractGroupsForContractResponse.GetContractGroupsForContractResponseV0.AsObject,
4463
+ }
4464
+
4465
+ export class DocumentTypeMemberships extends jspb.Message {
4466
+ getDocumentTypeName(): string;
4467
+ setDocumentTypeName(value: string): void;
4468
+
4469
+ clearContractGroupIdsList(): void;
4470
+ getContractGroupIdsList(): Array<Uint8Array | string>;
4471
+ getContractGroupIdsList_asU8(): Array<Uint8Array>;
4472
+ getContractGroupIdsList_asB64(): Array<string>;
4473
+ setContractGroupIdsList(value: Array<Uint8Array | string>): void;
4474
+ addContractGroupIds(value: Uint8Array | string, index?: number): Uint8Array | string;
4475
+
4476
+ serializeBinary(): Uint8Array;
4477
+ toObject(includeInstance?: boolean): DocumentTypeMemberships.AsObject;
4478
+ static toObject(includeInstance: boolean, msg: DocumentTypeMemberships): DocumentTypeMemberships.AsObject;
4479
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4480
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4481
+ static serializeBinaryToWriter(message: DocumentTypeMemberships, writer: jspb.BinaryWriter): void;
4482
+ static deserializeBinary(bytes: Uint8Array): DocumentTypeMemberships;
4483
+ static deserializeBinaryFromReader(message: DocumentTypeMemberships, reader: jspb.BinaryReader): DocumentTypeMemberships;
4484
+ }
4485
+
4486
+ export namespace DocumentTypeMemberships {
4487
+ export type AsObject = {
4488
+ documentTypeName: string,
4489
+ contractGroupIdsList: Array<Uint8Array | string>,
4490
+ }
4491
+ }
4492
+
4493
+ export class TokenMemberships extends jspb.Message {
4494
+ getTokenPosition(): number;
4495
+ setTokenPosition(value: number): void;
4496
+
4497
+ clearContractGroupIdsList(): void;
4498
+ getContractGroupIdsList(): Array<Uint8Array | string>;
4499
+ getContractGroupIdsList_asU8(): Array<Uint8Array>;
4500
+ getContractGroupIdsList_asB64(): Array<string>;
4501
+ setContractGroupIdsList(value: Array<Uint8Array | string>): void;
4502
+ addContractGroupIds(value: Uint8Array | string, index?: number): Uint8Array | string;
1790
4503
 
1791
4504
  serializeBinary(): Uint8Array;
1792
- toObject(includeInstance?: boolean): GetDataContractRequestV0.AsObject;
1793
- static toObject(includeInstance: boolean, msg: GetDataContractRequestV0): GetDataContractRequestV0.AsObject;
4505
+ toObject(includeInstance?: boolean): TokenMemberships.AsObject;
4506
+ static toObject(includeInstance: boolean, msg: TokenMemberships): TokenMemberships.AsObject;
1794
4507
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
1795
4508
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
1796
- static serializeBinaryToWriter(message: GetDataContractRequestV0, writer: jspb.BinaryWriter): void;
1797
- static deserializeBinary(bytes: Uint8Array): GetDataContractRequestV0;
1798
- static deserializeBinaryFromReader(message: GetDataContractRequestV0, reader: jspb.BinaryReader): GetDataContractRequestV0;
4509
+ static serializeBinaryToWriter(message: TokenMemberships, writer: jspb.BinaryWriter): void;
4510
+ static deserializeBinary(bytes: Uint8Array): TokenMemberships;
4511
+ static deserializeBinaryFromReader(message: TokenMemberships, reader: jspb.BinaryReader): TokenMemberships;
1799
4512
  }
1800
4513
 
1801
- export namespace GetDataContractRequestV0 {
4514
+ export namespace TokenMemberships {
1802
4515
  export type AsObject = {
1803
- id: Uint8Array | string,
1804
- prove: boolean,
4516
+ tokenPosition: number,
4517
+ contractGroupIdsList: Array<Uint8Array | string>,
1805
4518
  }
1806
4519
  }
1807
4520
 
1808
- export enum VersionCase {
1809
- VERSION_NOT_SET = 0,
1810
- V0 = 1,
1811
- }
1812
- }
4521
+ export class ContractGroupMemberships extends jspb.Message {
4522
+ clearContractGroupIdsList(): void;
4523
+ getContractGroupIdsList(): Array<Uint8Array | string>;
4524
+ getContractGroupIdsList_asU8(): Array<Uint8Array>;
4525
+ getContractGroupIdsList_asB64(): Array<string>;
4526
+ setContractGroupIdsList(value: Array<Uint8Array | string>): void;
4527
+ addContractGroupIds(value: Uint8Array | string, index?: number): Uint8Array | string;
1813
4528
 
1814
- export class GetDataContractResponse extends jspb.Message {
1815
- hasV0(): boolean;
1816
- clearV0(): void;
1817
- getV0(): GetDataContractResponse.GetDataContractResponseV0 | undefined;
1818
- setV0(value?: GetDataContractResponse.GetDataContractResponseV0): void;
4529
+ clearDocumentTypesList(): void;
4530
+ getDocumentTypesList(): Array<GetContractGroupsForContractResponse.DocumentTypeMemberships>;
4531
+ setDocumentTypesList(value: Array<GetContractGroupsForContractResponse.DocumentTypeMemberships>): void;
4532
+ addDocumentTypes(value?: GetContractGroupsForContractResponse.DocumentTypeMemberships, index?: number): GetContractGroupsForContractResponse.DocumentTypeMemberships;
1819
4533
 
1820
- getVersionCase(): GetDataContractResponse.VersionCase;
1821
- serializeBinary(): Uint8Array;
1822
- toObject(includeInstance?: boolean): GetDataContractResponse.AsObject;
1823
- static toObject(includeInstance: boolean, msg: GetDataContractResponse): GetDataContractResponse.AsObject;
1824
- static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
1825
- static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
1826
- static serializeBinaryToWriter(message: GetDataContractResponse, writer: jspb.BinaryWriter): void;
1827
- static deserializeBinary(bytes: Uint8Array): GetDataContractResponse;
1828
- static deserializeBinaryFromReader(message: GetDataContractResponse, reader: jspb.BinaryReader): GetDataContractResponse;
1829
- }
4534
+ clearTokensList(): void;
4535
+ getTokensList(): Array<GetContractGroupsForContractResponse.TokenMemberships>;
4536
+ setTokensList(value: Array<GetContractGroupsForContractResponse.TokenMemberships>): void;
4537
+ addTokens(value?: GetContractGroupsForContractResponse.TokenMemberships, index?: number): GetContractGroupsForContractResponse.TokenMemberships;
1830
4538
 
1831
- export namespace GetDataContractResponse {
1832
- export type AsObject = {
1833
- v0?: GetDataContractResponse.GetDataContractResponseV0.AsObject,
4539
+ serializeBinary(): Uint8Array;
4540
+ toObject(includeInstance?: boolean): ContractGroupMemberships.AsObject;
4541
+ static toObject(includeInstance: boolean, msg: ContractGroupMemberships): ContractGroupMemberships.AsObject;
4542
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4543
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4544
+ static serializeBinaryToWriter(message: ContractGroupMemberships, writer: jspb.BinaryWriter): void;
4545
+ static deserializeBinary(bytes: Uint8Array): ContractGroupMemberships;
4546
+ static deserializeBinaryFromReader(message: ContractGroupMemberships, reader: jspb.BinaryReader): ContractGroupMemberships;
1834
4547
  }
1835
4548
 
1836
- export class GetDataContractResponseV0 extends jspb.Message {
1837
- hasDataContract(): boolean;
1838
- clearDataContract(): void;
1839
- getDataContract(): Uint8Array | string;
1840
- getDataContract_asU8(): Uint8Array;
1841
- getDataContract_asB64(): string;
1842
- setDataContract(value: Uint8Array | string): void;
4549
+ export namespace ContractGroupMemberships {
4550
+ export type AsObject = {
4551
+ contractGroupIdsList: Array<Uint8Array | string>,
4552
+ documentTypesList: Array<GetContractGroupsForContractResponse.DocumentTypeMemberships.AsObject>,
4553
+ tokensList: Array<GetContractGroupsForContractResponse.TokenMemberships.AsObject>,
4554
+ }
4555
+ }
4556
+
4557
+ export class GetContractGroupsForContractResponseV0 extends jspb.Message {
4558
+ hasContractGroupMemberships(): boolean;
4559
+ clearContractGroupMemberships(): void;
4560
+ getContractGroupMemberships(): GetContractGroupsForContractResponse.ContractGroupMemberships | undefined;
4561
+ setContractGroupMemberships(value?: GetContractGroupsForContractResponse.ContractGroupMemberships): void;
1843
4562
 
1844
4563
  hasProof(): boolean;
1845
4564
  clearProof(): void;
@@ -1851,27 +4570,27 @@ export namespace GetDataContractResponse {
1851
4570
  getMetadata(): ResponseMetadata | undefined;
1852
4571
  setMetadata(value?: ResponseMetadata): void;
1853
4572
 
1854
- getResultCase(): GetDataContractResponseV0.ResultCase;
4573
+ getResultCase(): GetContractGroupsForContractResponseV0.ResultCase;
1855
4574
  serializeBinary(): Uint8Array;
1856
- toObject(includeInstance?: boolean): GetDataContractResponseV0.AsObject;
1857
- static toObject(includeInstance: boolean, msg: GetDataContractResponseV0): GetDataContractResponseV0.AsObject;
4575
+ toObject(includeInstance?: boolean): GetContractGroupsForContractResponseV0.AsObject;
4576
+ static toObject(includeInstance: boolean, msg: GetContractGroupsForContractResponseV0): GetContractGroupsForContractResponseV0.AsObject;
1858
4577
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
1859
4578
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
1860
- static serializeBinaryToWriter(message: GetDataContractResponseV0, writer: jspb.BinaryWriter): void;
1861
- static deserializeBinary(bytes: Uint8Array): GetDataContractResponseV0;
1862
- static deserializeBinaryFromReader(message: GetDataContractResponseV0, reader: jspb.BinaryReader): GetDataContractResponseV0;
4579
+ static serializeBinaryToWriter(message: GetContractGroupsForContractResponseV0, writer: jspb.BinaryWriter): void;
4580
+ static deserializeBinary(bytes: Uint8Array): GetContractGroupsForContractResponseV0;
4581
+ static deserializeBinaryFromReader(message: GetContractGroupsForContractResponseV0, reader: jspb.BinaryReader): GetContractGroupsForContractResponseV0;
1863
4582
  }
1864
4583
 
1865
- export namespace GetDataContractResponseV0 {
4584
+ export namespace GetContractGroupsForContractResponseV0 {
1866
4585
  export type AsObject = {
1867
- dataContract: Uint8Array | string,
4586
+ contractGroupMemberships?: GetContractGroupsForContractResponse.ContractGroupMemberships.AsObject,
1868
4587
  proof?: Proof.AsObject,
1869
4588
  metadata?: ResponseMetadata.AsObject,
1870
4589
  }
1871
4590
 
1872
4591
  export enum ResultCase {
1873
4592
  RESULT_NOT_SET = 0,
1874
- DATA_CONTRACT = 1,
4593
+ CONTRACT_GROUP_MEMBERSHIPS = 1,
1875
4594
  PROOF = 2,
1876
4595
  }
1877
4596
  }
@@ -1938,6 +4657,87 @@ export namespace GetDataContractsRequest {
1938
4657
  }
1939
4658
  }
1940
4659
 
4660
+ export class GetDataContractsByRangeRequest extends jspb.Message {
4661
+ hasV0(): boolean;
4662
+ clearV0(): void;
4663
+ getV0(): GetDataContractsByRangeRequest.GetDataContractsByRangeRequestV0 | undefined;
4664
+ setV0(value?: GetDataContractsByRangeRequest.GetDataContractsByRangeRequestV0): void;
4665
+
4666
+ getVersionCase(): GetDataContractsByRangeRequest.VersionCase;
4667
+ serializeBinary(): Uint8Array;
4668
+ toObject(includeInstance?: boolean): GetDataContractsByRangeRequest.AsObject;
4669
+ static toObject(includeInstance: boolean, msg: GetDataContractsByRangeRequest): GetDataContractsByRangeRequest.AsObject;
4670
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4671
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4672
+ static serializeBinaryToWriter(message: GetDataContractsByRangeRequest, writer: jspb.BinaryWriter): void;
4673
+ static deserializeBinary(bytes: Uint8Array): GetDataContractsByRangeRequest;
4674
+ static deserializeBinaryFromReader(message: GetDataContractsByRangeRequest, reader: jspb.BinaryReader): GetDataContractsByRangeRequest;
4675
+ }
4676
+
4677
+ export namespace GetDataContractsByRangeRequest {
4678
+ export type AsObject = {
4679
+ v0?: GetDataContractsByRangeRequest.GetDataContractsByRangeRequestV0.AsObject,
4680
+ }
4681
+
4682
+ export class GetDataContractsByRangeRequestV0 extends jspb.Message {
4683
+ hasLimit(): boolean;
4684
+ clearLimit(): void;
4685
+ getLimit(): number;
4686
+ setLimit(value: number): void;
4687
+
4688
+ hasStartAfter(): boolean;
4689
+ clearStartAfter(): void;
4690
+ getStartAfter(): Uint8Array | string;
4691
+ getStartAfter_asU8(): Uint8Array;
4692
+ getStartAfter_asB64(): string;
4693
+ setStartAfter(value: Uint8Array | string): void;
4694
+
4695
+ hasStartAt(): boolean;
4696
+ clearStartAt(): void;
4697
+ getStartAt(): Uint8Array | string;
4698
+ getStartAt_asU8(): Uint8Array;
4699
+ getStartAt_asB64(): string;
4700
+ setStartAt(value: Uint8Array | string): void;
4701
+
4702
+ getIdsOnly(): boolean;
4703
+ setIdsOnly(value: boolean): void;
4704
+
4705
+ getProve(): boolean;
4706
+ setProve(value: boolean): void;
4707
+
4708
+ getStartCase(): GetDataContractsByRangeRequestV0.StartCase;
4709
+ serializeBinary(): Uint8Array;
4710
+ toObject(includeInstance?: boolean): GetDataContractsByRangeRequestV0.AsObject;
4711
+ static toObject(includeInstance: boolean, msg: GetDataContractsByRangeRequestV0): GetDataContractsByRangeRequestV0.AsObject;
4712
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
4713
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
4714
+ static serializeBinaryToWriter(message: GetDataContractsByRangeRequestV0, writer: jspb.BinaryWriter): void;
4715
+ static deserializeBinary(bytes: Uint8Array): GetDataContractsByRangeRequestV0;
4716
+ static deserializeBinaryFromReader(message: GetDataContractsByRangeRequestV0, reader: jspb.BinaryReader): GetDataContractsByRangeRequestV0;
4717
+ }
4718
+
4719
+ export namespace GetDataContractsByRangeRequestV0 {
4720
+ export type AsObject = {
4721
+ limit: number,
4722
+ startAfter: Uint8Array | string,
4723
+ startAt: Uint8Array | string,
4724
+ idsOnly: boolean,
4725
+ prove: boolean,
4726
+ }
4727
+
4728
+ export enum StartCase {
4729
+ START_NOT_SET = 0,
4730
+ START_AFTER = 2,
4731
+ START_AT = 3,
4732
+ }
4733
+ }
4734
+
4735
+ export enum VersionCase {
4736
+ VERSION_NOT_SET = 0,
4737
+ V0 = 1,
4738
+ }
4739
+ }
4740
+
1941
4741
  export class GetDataContractsResponse extends jspb.Message {
1942
4742
  hasV0(): boolean;
1943
4743
  clearV0(): void;
@@ -2441,6 +5241,62 @@ export namespace GetDocumentsRequest {
2441
5241
  export const Selector: SelectorMap;
2442
5242
  }
2443
5243
 
5244
+ export class IntegerRangeSelection extends jspb.Message {
5245
+ hasStart(): boolean;
5246
+ clearStart(): void;
5247
+ getStart(): GetDocumentsRequest.DocumentFieldValue | undefined;
5248
+ setStart(value?: GetDocumentsRequest.DocumentFieldValue): void;
5249
+
5250
+ hasGrid(): boolean;
5251
+ clearGrid(): void;
5252
+ getGrid(): GetDocumentsRequest.IntegerRangeSelection.Grid | undefined;
5253
+ setGrid(value?: GetDocumentsRequest.IntegerRangeSelection.Grid): void;
5254
+
5255
+ serializeBinary(): Uint8Array;
5256
+ toObject(includeInstance?: boolean): IntegerRangeSelection.AsObject;
5257
+ static toObject(includeInstance: boolean, msg: IntegerRangeSelection): IntegerRangeSelection.AsObject;
5258
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
5259
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
5260
+ static serializeBinaryToWriter(message: IntegerRangeSelection, writer: jspb.BinaryWriter): void;
5261
+ static deserializeBinary(bytes: Uint8Array): IntegerRangeSelection;
5262
+ static deserializeBinaryFromReader(message: IntegerRangeSelection, reader: jspb.BinaryReader): IntegerRangeSelection;
5263
+ }
5264
+
5265
+ export namespace IntegerRangeSelection {
5266
+ export type AsObject = {
5267
+ start?: GetDocumentsRequest.DocumentFieldValue.AsObject,
5268
+ grid?: GetDocumentsRequest.IntegerRangeSelection.Grid.AsObject,
5269
+ }
5270
+
5271
+ export class Grid extends jspb.Message {
5272
+ getRange(): string;
5273
+ setRange(value: string): void;
5274
+
5275
+ getStep(): string;
5276
+ setStep(value: string): void;
5277
+
5278
+ getPhase(): string;
5279
+ setPhase(value: string): void;
5280
+
5281
+ serializeBinary(): Uint8Array;
5282
+ toObject(includeInstance?: boolean): Grid.AsObject;
5283
+ static toObject(includeInstance: boolean, msg: Grid): Grid.AsObject;
5284
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
5285
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
5286
+ static serializeBinaryToWriter(message: Grid, writer: jspb.BinaryWriter): void;
5287
+ static deserializeBinary(bytes: Uint8Array): Grid;
5288
+ static deserializeBinaryFromReader(message: Grid, reader: jspb.BinaryReader): Grid;
5289
+ }
5290
+
5291
+ export namespace Grid {
5292
+ export type AsObject = {
5293
+ range: string,
5294
+ step: string,
5295
+ phase: string,
5296
+ }
5297
+ }
5298
+ }
5299
+
2444
5300
  export class WhereClause extends jspb.Message {
2445
5301
  getField(): string;
2446
5302
  setField(value: string): void;
@@ -2458,6 +5314,11 @@ export namespace GetDocumentsRequest {
2458
5314
  getTimeRange(): GetDocumentsRequest.TimeRangeSelection | undefined;
2459
5315
  setTimeRange(value?: GetDocumentsRequest.TimeRangeSelection): void;
2460
5316
 
5317
+ hasIntegerRange(): boolean;
5318
+ clearIntegerRange(): void;
5319
+ getIntegerRange(): GetDocumentsRequest.IntegerRangeSelection | undefined;
5320
+ setIntegerRange(value?: GetDocumentsRequest.IntegerRangeSelection): void;
5321
+
2461
5322
  serializeBinary(): Uint8Array;
2462
5323
  toObject(includeInstance?: boolean): WhereClause.AsObject;
2463
5324
  static toObject(includeInstance: boolean, msg: WhereClause): WhereClause.AsObject;
@@ -2474,6 +5335,7 @@ export namespace GetDocumentsRequest {
2474
5335
  operator: GetDocumentsRequest.WhereOperatorMap[keyof GetDocumentsRequest.WhereOperatorMap],
2475
5336
  value?: GetDocumentsRequest.DocumentFieldValue.AsObject,
2476
5337
  timeRange?: GetDocumentsRequest.TimeRangeSelection.AsObject,
5338
+ integerRange?: GetDocumentsRequest.IntegerRangeSelection.AsObject,
2477
5339
  }
2478
5340
  }
2479
5341
 
@@ -2939,6 +5801,7 @@ export namespace GetDocumentsRequest {
2939
5801
  IN: 9;
2940
5802
  STARTS_WITH: 10;
2941
5803
  IN_TIME_RANGE: 11;
5804
+ IN_INTEGER_RANGE: 12;
2942
5805
  }
2943
5806
 
2944
5807
  export const WhereOperator: WhereOperatorMap;
@@ -3571,6 +6434,18 @@ export namespace GetDocumentsResponse {
3571
6434
  setOuterDocumentsList(value: Array<Uint8Array | string>): void;
3572
6435
  addOuterDocuments(value: Uint8Array | string, index?: number): Uint8Array | string;
3573
6436
 
6437
+ clearMissingOuterIdsList(): void;
6438
+ getMissingOuterIdsList(): Array<Uint8Array | string>;
6439
+ getMissingOuterIdsList_asU8(): Array<Uint8Array>;
6440
+ getMissingOuterIdsList_asB64(): Array<string>;
6441
+ setMissingOuterIdsList(value: Array<Uint8Array | string>): void;
6442
+ addMissingOuterIds(value: Uint8Array | string, index?: number): Uint8Array | string;
6443
+
6444
+ clearRemovedOuterDocumentsList(): void;
6445
+ getRemovedOuterDocumentsList(): Array<GetContractDocumentRemovalsResponse.ContractDocumentRemoval>;
6446
+ setRemovedOuterDocumentsList(value: Array<GetContractDocumentRemovalsResponse.ContractDocumentRemoval>): void;
6447
+ addRemovedOuterDocuments(value?: GetContractDocumentRemovalsResponse.ContractDocumentRemoval, index?: number): GetContractDocumentRemovalsResponse.ContractDocumentRemoval;
6448
+
3574
6449
  serializeBinary(): Uint8Array;
3575
6450
  toObject(includeInstance?: boolean): ChainedDocuments.AsObject;
3576
6451
  static toObject(includeInstance: boolean, msg: ChainedDocuments): ChainedDocuments.AsObject;
@@ -3585,6 +6460,8 @@ export namespace GetDocumentsResponse {
3585
6460
  export type AsObject = {
3586
6461
  innerDocumentsList: Array<Uint8Array | string>,
3587
6462
  outerDocumentsList: Array<Uint8Array | string>,
6463
+ missingOuterIdsList: Array<Uint8Array | string>,
6464
+ removedOuterDocumentsList: Array<GetContractDocumentRemovalsResponse.ContractDocumentRemoval.AsObject>,
3588
6465
  }
3589
6466
  }
3590
6467
 
@@ -3628,6 +6505,18 @@ export namespace GetDocumentsResponse {
3628
6505
  getCounts(): GetDocumentsResponse.GetDocumentsResponseV1.CountEntries | undefined;
3629
6506
  setCounts(value?: GetDocumentsResponse.GetDocumentsResponseV1.CountEntries): void;
3630
6507
 
6508
+ clearMissingIdsList(): void;
6509
+ getMissingIdsList(): Array<Uint8Array | string>;
6510
+ getMissingIdsList_asU8(): Array<Uint8Array>;
6511
+ getMissingIdsList_asB64(): Array<string>;
6512
+ setMissingIdsList(value: Array<Uint8Array | string>): void;
6513
+ addMissingIds(value: Uint8Array | string, index?: number): Uint8Array | string;
6514
+
6515
+ clearRemovedList(): void;
6516
+ getRemovedList(): Array<GetContractDocumentRemovalsResponse.ContractDocumentRemoval>;
6517
+ setRemovedList(value: Array<GetContractDocumentRemovalsResponse.ContractDocumentRemoval>): void;
6518
+ addRemoved(value?: GetContractDocumentRemovalsResponse.ContractDocumentRemoval, index?: number): GetContractDocumentRemovalsResponse.ContractDocumentRemoval;
6519
+
3631
6520
  getResultCase(): SubQueryResult.ResultCase;
3632
6521
  serializeBinary(): Uint8Array;
3633
6522
  toObject(includeInstance?: boolean): SubQueryResult.AsObject;
@@ -3643,6 +6532,8 @@ export namespace GetDocumentsResponse {
3643
6532
  export type AsObject = {
3644
6533
  documents?: GetDocumentsResponse.GetDocumentsResponseV1.Documents.AsObject,
3645
6534
  counts?: GetDocumentsResponse.GetDocumentsResponseV1.CountEntries.AsObject,
6535
+ missingIdsList: Array<Uint8Array | string>,
6536
+ removedList: Array<GetContractDocumentRemovalsResponse.ContractDocumentRemoval.AsObject>,
3646
6537
  }
3647
6538
 
3648
6539
  export enum ResultCase {
@@ -4205,6 +7096,9 @@ export namespace WaitForStateTransitionResultRequest {
4205
7096
  getProve(): boolean;
4206
7097
  setProve(value: boolean): void;
4207
7098
 
7099
+ getRequestUserBalance(): boolean;
7100
+ setRequestUserBalance(value: boolean): void;
7101
+
4208
7102
  serializeBinary(): Uint8Array;
4209
7103
  toObject(includeInstance?: boolean): WaitForStateTransitionResultRequestV0.AsObject;
4210
7104
  static toObject(includeInstance: boolean, msg: WaitForStateTransitionResultRequestV0): WaitForStateTransitionResultRequestV0.AsObject;
@@ -4219,6 +7113,7 @@ export namespace WaitForStateTransitionResultRequest {
4219
7113
  export type AsObject = {
4220
7114
  stateTransitionHash: Uint8Array | string,
4221
7115
  prove: boolean,
7116
+ requestUserBalance: boolean,
4222
7117
  }
4223
7118
  }
4224
7119
 
@@ -4250,6 +7145,26 @@ export namespace WaitForStateTransitionResultResponse {
4250
7145
  v0?: WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0.AsObject,
4251
7146
  }
4252
7147
 
7148
+ export class SuccessWithOwnerBalance extends jspb.Message {
7149
+ getOwnerBalance(): string;
7150
+ setOwnerBalance(value: string): void;
7151
+
7152
+ serializeBinary(): Uint8Array;
7153
+ toObject(includeInstance?: boolean): SuccessWithOwnerBalance.AsObject;
7154
+ static toObject(includeInstance: boolean, msg: SuccessWithOwnerBalance): SuccessWithOwnerBalance.AsObject;
7155
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
7156
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
7157
+ static serializeBinaryToWriter(message: SuccessWithOwnerBalance, writer: jspb.BinaryWriter): void;
7158
+ static deserializeBinary(bytes: Uint8Array): SuccessWithOwnerBalance;
7159
+ static deserializeBinaryFromReader(message: SuccessWithOwnerBalance, reader: jspb.BinaryReader): SuccessWithOwnerBalance;
7160
+ }
7161
+
7162
+ export namespace SuccessWithOwnerBalance {
7163
+ export type AsObject = {
7164
+ ownerBalance: string,
7165
+ }
7166
+ }
7167
+
4253
7168
  export class WaitForStateTransitionResultResponseV0 extends jspb.Message {
4254
7169
  hasError(): boolean;
4255
7170
  clearError(): void;
@@ -4261,6 +7176,11 @@ export namespace WaitForStateTransitionResultResponse {
4261
7176
  getProof(): Proof | undefined;
4262
7177
  setProof(value?: Proof): void;
4263
7178
 
7179
+ hasSuccessWithOwnerBalance(): boolean;
7180
+ clearSuccessWithOwnerBalance(): void;
7181
+ getSuccessWithOwnerBalance(): WaitForStateTransitionResultResponse.SuccessWithOwnerBalance | undefined;
7182
+ setSuccessWithOwnerBalance(value?: WaitForStateTransitionResultResponse.SuccessWithOwnerBalance): void;
7183
+
4264
7184
  hasMetadata(): boolean;
4265
7185
  clearMetadata(): void;
4266
7186
  getMetadata(): ResponseMetadata | undefined;
@@ -4281,6 +7201,7 @@ export namespace WaitForStateTransitionResultResponse {
4281
7201
  export type AsObject = {
4282
7202
  error?: StateTransitionBroadcastError.AsObject,
4283
7203
  proof?: Proof.AsObject,
7204
+ successWithOwnerBalance?: WaitForStateTransitionResultResponse.SuccessWithOwnerBalance.AsObject,
4284
7205
  metadata?: ResponseMetadata.AsObject,
4285
7206
  }
4286
7207
 
@@ -4288,6 +7209,7 @@ export namespace WaitForStateTransitionResultResponse {
4288
7209
  RESULT_NOT_SET = 0,
4289
7210
  ERROR = 1,
4290
7211
  PROOF = 2,
7212
+ SUCCESS_WITH_OWNER_BALANCE = 4,
4291
7213
  }
4292
7214
  }
4293
7215
 
@@ -10458,6 +13380,70 @@ export namespace GetGroupActionsResponse {
10458
13380
  }
10459
13381
  }
10460
13382
 
13383
+ export class MintToPoolEvent extends jspb.Message {
13384
+ getAmount(): number;
13385
+ setAmount(value: number): void;
13386
+
13387
+ getActionsDigest(): Uint8Array | string;
13388
+ getActionsDigest_asU8(): Uint8Array;
13389
+ getActionsDigest_asB64(): string;
13390
+ setActionsDigest(value: Uint8Array | string): void;
13391
+
13392
+ hasPublicNote(): boolean;
13393
+ clearPublicNote(): void;
13394
+ getPublicNote(): string;
13395
+ setPublicNote(value: string): void;
13396
+
13397
+ serializeBinary(): Uint8Array;
13398
+ toObject(includeInstance?: boolean): MintToPoolEvent.AsObject;
13399
+ static toObject(includeInstance: boolean, msg: MintToPoolEvent): MintToPoolEvent.AsObject;
13400
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
13401
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
13402
+ static serializeBinaryToWriter(message: MintToPoolEvent, writer: jspb.BinaryWriter): void;
13403
+ static deserializeBinary(bytes: Uint8Array): MintToPoolEvent;
13404
+ static deserializeBinaryFromReader(message: MintToPoolEvent, reader: jspb.BinaryReader): MintToPoolEvent;
13405
+ }
13406
+
13407
+ export namespace MintToPoolEvent {
13408
+ export type AsObject = {
13409
+ amount: number,
13410
+ actionsDigest: Uint8Array | string,
13411
+ publicNote: string,
13412
+ }
13413
+ }
13414
+
13415
+ export class BurnFromPoolEvent extends jspb.Message {
13416
+ getAmount(): number;
13417
+ setAmount(value: number): void;
13418
+
13419
+ getActionsDigest(): Uint8Array | string;
13420
+ getActionsDigest_asU8(): Uint8Array;
13421
+ getActionsDigest_asB64(): string;
13422
+ setActionsDigest(value: Uint8Array | string): void;
13423
+
13424
+ hasPublicNote(): boolean;
13425
+ clearPublicNote(): void;
13426
+ getPublicNote(): string;
13427
+ setPublicNote(value: string): void;
13428
+
13429
+ serializeBinary(): Uint8Array;
13430
+ toObject(includeInstance?: boolean): BurnFromPoolEvent.AsObject;
13431
+ static toObject(includeInstance: boolean, msg: BurnFromPoolEvent): BurnFromPoolEvent.AsObject;
13432
+ static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
13433
+ static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
13434
+ static serializeBinaryToWriter(message: BurnFromPoolEvent, writer: jspb.BinaryWriter): void;
13435
+ static deserializeBinary(bytes: Uint8Array): BurnFromPoolEvent;
13436
+ static deserializeBinaryFromReader(message: BurnFromPoolEvent, reader: jspb.BinaryReader): BurnFromPoolEvent;
13437
+ }
13438
+
13439
+ export namespace BurnFromPoolEvent {
13440
+ export type AsObject = {
13441
+ amount: number,
13442
+ actionsDigest: Uint8Array | string,
13443
+ publicNote: string,
13444
+ }
13445
+ }
13446
+
10461
13447
  export class GroupActionEvent extends jspb.Message {
10462
13448
  hasTokenEvent(): boolean;
10463
13449
  clearTokenEvent(): void;
@@ -10641,6 +13627,16 @@ export namespace GetGroupActionsResponse {
10641
13627
  getUpdatePrice(): GetGroupActionsResponse.GetGroupActionsResponseV0.UpdateDirectPurchasePriceEvent | undefined;
10642
13628
  setUpdatePrice(value?: GetGroupActionsResponse.GetGroupActionsResponseV0.UpdateDirectPurchasePriceEvent): void;
10643
13629
 
13630
+ hasMintToPool(): boolean;
13631
+ clearMintToPool(): void;
13632
+ getMintToPool(): GetGroupActionsResponse.GetGroupActionsResponseV0.MintToPoolEvent | undefined;
13633
+ setMintToPool(value?: GetGroupActionsResponse.GetGroupActionsResponseV0.MintToPoolEvent): void;
13634
+
13635
+ hasBurnFromPool(): boolean;
13636
+ clearBurnFromPool(): void;
13637
+ getBurnFromPool(): GetGroupActionsResponse.GetGroupActionsResponseV0.BurnFromPoolEvent | undefined;
13638
+ setBurnFromPool(value?: GetGroupActionsResponse.GetGroupActionsResponseV0.BurnFromPoolEvent): void;
13639
+
10644
13640
  getTypeCase(): TokenEvent.TypeCase;
10645
13641
  serializeBinary(): Uint8Array;
10646
13642
  toObject(includeInstance?: boolean): TokenEvent.AsObject;
@@ -10662,6 +13658,8 @@ export namespace GetGroupActionsResponse {
10662
13658
  emergencyAction?: GetGroupActionsResponse.GetGroupActionsResponseV0.EmergencyActionEvent.AsObject,
10663
13659
  tokenConfigUpdate?: GetGroupActionsResponse.GetGroupActionsResponseV0.TokenConfigUpdateEvent.AsObject,
10664
13660
  updatePrice?: GetGroupActionsResponse.GetGroupActionsResponseV0.UpdateDirectPurchasePriceEvent.AsObject,
13661
+ mintToPool?: GetGroupActionsResponse.GetGroupActionsResponseV0.MintToPoolEvent.AsObject,
13662
+ burnFromPool?: GetGroupActionsResponse.GetGroupActionsResponseV0.BurnFromPoolEvent.AsObject,
10665
13663
  }
10666
13664
 
10667
13665
  export enum TypeCase {
@@ -10674,6 +13672,8 @@ export namespace GetGroupActionsResponse {
10674
13672
  EMERGENCY_ACTION = 6,
10675
13673
  TOKEN_CONFIG_UPDATE = 7,
10676
13674
  UPDATE_PRICE = 8,
13675
+ MINT_TO_POOL = 9,
13676
+ BURN_FROM_POOL = 10,
10677
13677
  }
10678
13678
  }
10679
13679
 
@@ -11968,6 +14968,13 @@ export namespace GetShieldedEncryptedNotesRequest {
11968
14968
  getProve(): boolean;
11969
14969
  setProve(value: boolean): void;
11970
14970
 
14971
+ hasTokenId(): boolean;
14972
+ clearTokenId(): void;
14973
+ getTokenId(): Uint8Array | string;
14974
+ getTokenId_asU8(): Uint8Array;
14975
+ getTokenId_asB64(): string;
14976
+ setTokenId(value: Uint8Array | string): void;
14977
+
11971
14978
  serializeBinary(): Uint8Array;
11972
14979
  toObject(includeInstance?: boolean): GetShieldedEncryptedNotesRequestV0.AsObject;
11973
14980
  static toObject(includeInstance: boolean, msg: GetShieldedEncryptedNotesRequestV0): GetShieldedEncryptedNotesRequestV0.AsObject;
@@ -11983,6 +14990,7 @@ export namespace GetShieldedEncryptedNotesRequest {
11983
14990
  startIndex: number,
11984
14991
  count: number,
11985
14992
  prove: boolean,
14993
+ tokenId: Uint8Array | string,
11986
14994
  }
11987
14995
  }
11988
14996
 
@@ -12149,6 +15157,13 @@ export namespace GetShieldedAnchorsRequest {
12149
15157
  getProve(): boolean;
12150
15158
  setProve(value: boolean): void;
12151
15159
 
15160
+ hasTokenId(): boolean;
15161
+ clearTokenId(): void;
15162
+ getTokenId(): Uint8Array | string;
15163
+ getTokenId_asU8(): Uint8Array;
15164
+ getTokenId_asB64(): string;
15165
+ setTokenId(value: Uint8Array | string): void;
15166
+
12152
15167
  serializeBinary(): Uint8Array;
12153
15168
  toObject(includeInstance?: boolean): GetShieldedAnchorsRequestV0.AsObject;
12154
15169
  static toObject(includeInstance: boolean, msg: GetShieldedAnchorsRequestV0): GetShieldedAnchorsRequestV0.AsObject;
@@ -12162,6 +15177,7 @@ export namespace GetShieldedAnchorsRequest {
12162
15177
  export namespace GetShieldedAnchorsRequestV0 {
12163
15178
  export type AsObject = {
12164
15179
  prove: boolean,
15180
+ tokenId: Uint8Array | string,
12165
15181
  }
12166
15182
  }
12167
15183
 
@@ -12290,6 +15306,13 @@ export namespace GetMostRecentShieldedAnchorRequest {
12290
15306
  getProve(): boolean;
12291
15307
  setProve(value: boolean): void;
12292
15308
 
15309
+ hasTokenId(): boolean;
15310
+ clearTokenId(): void;
15311
+ getTokenId(): Uint8Array | string;
15312
+ getTokenId_asU8(): Uint8Array;
15313
+ getTokenId_asB64(): string;
15314
+ setTokenId(value: Uint8Array | string): void;
15315
+
12293
15316
  serializeBinary(): Uint8Array;
12294
15317
  toObject(includeInstance?: boolean): GetMostRecentShieldedAnchorRequestV0.AsObject;
12295
15318
  static toObject(includeInstance: boolean, msg: GetMostRecentShieldedAnchorRequestV0): GetMostRecentShieldedAnchorRequestV0.AsObject;
@@ -12303,6 +15326,7 @@ export namespace GetMostRecentShieldedAnchorRequest {
12303
15326
  export namespace GetMostRecentShieldedAnchorRequestV0 {
12304
15327
  export type AsObject = {
12305
15328
  prove: boolean,
15329
+ tokenId: Uint8Array | string,
12306
15330
  }
12307
15331
  }
12308
15332
 
@@ -12409,6 +15433,13 @@ export namespace GetShieldedPoolStateRequest {
12409
15433
  getProve(): boolean;
12410
15434
  setProve(value: boolean): void;
12411
15435
 
15436
+ hasTokenId(): boolean;
15437
+ clearTokenId(): void;
15438
+ getTokenId(): Uint8Array | string;
15439
+ getTokenId_asU8(): Uint8Array;
15440
+ getTokenId_asB64(): string;
15441
+ setTokenId(value: Uint8Array | string): void;
15442
+
12412
15443
  serializeBinary(): Uint8Array;
12413
15444
  toObject(includeInstance?: boolean): GetShieldedPoolStateRequestV0.AsObject;
12414
15445
  static toObject(includeInstance: boolean, msg: GetShieldedPoolStateRequestV0): GetShieldedPoolStateRequestV0.AsObject;
@@ -12422,6 +15453,7 @@ export namespace GetShieldedPoolStateRequest {
12422
15453
  export namespace GetShieldedPoolStateRequestV0 {
12423
15454
  export type AsObject = {
12424
15455
  prove: boolean,
15456
+ tokenId: Uint8Array | string,
12425
15457
  }
12426
15458
  }
12427
15459
 
@@ -12526,6 +15558,13 @@ export namespace GetShieldedNotesCountRequest {
12526
15558
  getProve(): boolean;
12527
15559
  setProve(value: boolean): void;
12528
15560
 
15561
+ hasTokenId(): boolean;
15562
+ clearTokenId(): void;
15563
+ getTokenId(): Uint8Array | string;
15564
+ getTokenId_asU8(): Uint8Array;
15565
+ getTokenId_asB64(): string;
15566
+ setTokenId(value: Uint8Array | string): void;
15567
+
12529
15568
  serializeBinary(): Uint8Array;
12530
15569
  toObject(includeInstance?: boolean): GetShieldedNotesCountRequestV0.AsObject;
12531
15570
  static toObject(includeInstance: boolean, msg: GetShieldedNotesCountRequestV0): GetShieldedNotesCountRequestV0.AsObject;
@@ -12539,6 +15578,7 @@ export namespace GetShieldedNotesCountRequest {
12539
15578
  export namespace GetShieldedNotesCountRequestV0 {
12540
15579
  export type AsObject = {
12541
15580
  prove: boolean,
15581
+ tokenId: Uint8Array | string,
12542
15582
  }
12543
15583
  }
12544
15584
 
@@ -12650,6 +15690,13 @@ export namespace GetShieldedNullifiersRequest {
12650
15690
  getProve(): boolean;
12651
15691
  setProve(value: boolean): void;
12652
15692
 
15693
+ hasTokenId(): boolean;
15694
+ clearTokenId(): void;
15695
+ getTokenId(): Uint8Array | string;
15696
+ getTokenId_asU8(): Uint8Array;
15697
+ getTokenId_asB64(): string;
15698
+ setTokenId(value: Uint8Array | string): void;
15699
+
12653
15700
  serializeBinary(): Uint8Array;
12654
15701
  toObject(includeInstance?: boolean): GetShieldedNullifiersRequestV0.AsObject;
12655
15702
  static toObject(includeInstance: boolean, msg: GetShieldedNullifiersRequestV0): GetShieldedNullifiersRequestV0.AsObject;
@@ -12664,6 +15711,7 @@ export namespace GetShieldedNullifiersRequest {
12664
15711
  export type AsObject = {
12665
15712
  nullifiersList: Array<Uint8Array | string>,
12666
15713
  prove: boolean,
15714
+ tokenId: Uint8Array | string,
12667
15715
  }
12668
15716
  }
12669
15717
 
@@ -12800,3 +15848,12 @@ export interface KeyPurposeMap {
12800
15848
 
12801
15849
  export const KeyPurpose: KeyPurposeMap;
12802
15850
 
15851
+ export interface ContractModerationListMap {
15852
+ CONTRACT_MODERATION_LIST_UNSPECIFIED: 0;
15853
+ CONTRACT_MODERATION_LIST_BANLIST: 1;
15854
+ CONTRACT_MODERATION_LIST_SUSPENSIONS: 2;
15855
+ CONTRACT_MODERATION_LIST_WARNINGS: 3;
15856
+ }
15857
+
15858
+ export const ContractModerationList: ContractModerationListMap;
15859
+