@latticexyz/services 1.42.0 → 1.43.0

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.
@@ -1,1878 +0,0 @@
1
- /* eslint-disable */
2
- import type { CallContext, CallOptions } from "nice-grpc-common";
3
- import _m0 from "protobufjs/minimal";
4
-
5
- export const protobufPackage = "mode";
6
-
7
- /** A Row is just a list of raw bytes. */
8
- export interface Row {
9
- values: Uint8Array[];
10
- }
11
-
12
- /** A GenericTable is a representation of a table. */
13
- export interface GenericTable {
14
- cols: string[];
15
- rows: Row[];
16
- types: string[];
17
- }
18
-
19
- export interface QueryLayerResponse {
20
- tables: { [key: string]: GenericTable };
21
- }
22
-
23
- export interface QueryLayerResponse_TablesEntry {
24
- key: string;
25
- value: GenericTable | undefined;
26
- }
27
-
28
- export interface QueryLayerStateResponse {
29
- chainTables: { [key: string]: GenericTable };
30
- worldTables: { [key: string]: GenericTable };
31
- }
32
-
33
- export interface QueryLayerStateResponse_ChainTablesEntry {
34
- key: string;
35
- value: GenericTable | undefined;
36
- }
37
-
38
- export interface QueryLayerStateResponse_WorldTablesEntry {
39
- key: string;
40
- value: GenericTable | undefined;
41
- }
42
-
43
- export interface QueryLayerStateStreamResponse {
44
- inserted: QueryLayerStateResponse | undefined;
45
- updated: QueryLayerStateResponse | undefined;
46
- deleted: QueryLayerStateResponse | undefined;
47
- }
48
-
49
- export interface Namespace {
50
- chainId: string;
51
- worldAddress: string;
52
- }
53
-
54
- export interface StateRequest {
55
- /** Namespace. */
56
- namespace: Namespace | undefined;
57
- /**
58
- * Selection of world and chain tables. If left empty, all tables
59
- * are included.
60
- */
61
- worldTables: string[];
62
- chainTables: string[];
63
- }
64
-
65
- export interface SingleStateRequest {
66
- /** Namespace. */
67
- namespace: Namespace | undefined;
68
- /** Table. */
69
- table: string;
70
- /** Filters. */
71
- filter: Filter[];
72
- /** Projections. */
73
- project: ProjectedField[];
74
- }
75
-
76
- export interface FindRequest {
77
- from: string;
78
- filter: Filter[];
79
- project: ProjectedField[];
80
- /** Namespace. */
81
- namespace: Namespace | undefined;
82
- /** Options. */
83
- options: FindRequestOptions | undefined;
84
- }
85
-
86
- export interface FindAllRequest {
87
- tables: string[];
88
- /** Namespace. */
89
- namespace: Namespace | undefined;
90
- /** Options. */
91
- options: FindRequestOptions | undefined;
92
- }
93
-
94
- export interface JoinRequest {
95
- on: FieldPair | undefined;
96
- children: FindRequest[];
97
- /** Namespace. */
98
- namespace: Namespace | undefined;
99
- }
100
-
101
- export interface DeleteRequest {
102
- from: string;
103
- filter: Filter[];
104
- }
105
-
106
- export interface UpdateRequest {
107
- target: string;
108
- filter: Filter[];
109
- row: { [key: string]: string };
110
- }
111
-
112
- export interface UpdateRequest_RowEntry {
113
- key: string;
114
- value: string;
115
- }
116
-
117
- export interface InsertRequest {
118
- into: string;
119
- row: { [key: string]: string };
120
- }
121
-
122
- export interface InsertRequest_RowEntry {
123
- key: string;
124
- value: string;
125
- }
126
-
127
- export interface CreateRequest {
128
- name: string;
129
- }
130
-
131
- export interface FindRequestOptions {
132
- compressed: boolean;
133
- group: boolean;
134
- negate: boolean;
135
- }
136
-
137
- export interface Field {
138
- tableName: string;
139
- tableField: string;
140
- }
141
-
142
- export interface FieldPair {
143
- field1: Field | undefined;
144
- field2: Field | undefined;
145
- }
146
-
147
- export interface ProjectedField {
148
- field: Field | undefined;
149
- rename?: string | undefined;
150
- }
151
-
152
- export interface Filter {
153
- field: Field | undefined;
154
- operator: string;
155
- value: string;
156
- function: string;
157
- }
158
-
159
- function createBaseRow(): Row {
160
- return { values: [] };
161
- }
162
-
163
- export const Row = {
164
- encode(message: Row, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
165
- for (const v of message.values) {
166
- writer.uint32(18).bytes(v!);
167
- }
168
- return writer;
169
- },
170
-
171
- decode(input: _m0.Reader | Uint8Array, length?: number): Row {
172
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
173
- let end = length === undefined ? reader.len : reader.pos + length;
174
- const message = createBaseRow();
175
- while (reader.pos < end) {
176
- const tag = reader.uint32();
177
- switch (tag >>> 3) {
178
- case 2:
179
- if (tag != 18) {
180
- break;
181
- }
182
-
183
- message.values.push(reader.bytes());
184
- continue;
185
- }
186
- if ((tag & 7) == 4 || tag == 0) {
187
- break;
188
- }
189
- reader.skipType(tag & 7);
190
- }
191
- return message;
192
- },
193
-
194
- create(base?: DeepPartial<Row>): Row {
195
- return Row.fromPartial(base ?? {});
196
- },
197
-
198
- fromPartial(object: DeepPartial<Row>): Row {
199
- const message = createBaseRow();
200
- message.values = object.values?.map((e) => e) || [];
201
- return message;
202
- },
203
- };
204
-
205
- function createBaseGenericTable(): GenericTable {
206
- return { cols: [], rows: [], types: [] };
207
- }
208
-
209
- export const GenericTable = {
210
- encode(message: GenericTable, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
211
- for (const v of message.cols) {
212
- writer.uint32(10).string(v!);
213
- }
214
- for (const v of message.rows) {
215
- Row.encode(v!, writer.uint32(18).fork()).ldelim();
216
- }
217
- for (const v of message.types) {
218
- writer.uint32(26).string(v!);
219
- }
220
- return writer;
221
- },
222
-
223
- decode(input: _m0.Reader | Uint8Array, length?: number): GenericTable {
224
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
225
- let end = length === undefined ? reader.len : reader.pos + length;
226
- const message = createBaseGenericTable();
227
- while (reader.pos < end) {
228
- const tag = reader.uint32();
229
- switch (tag >>> 3) {
230
- case 1:
231
- if (tag != 10) {
232
- break;
233
- }
234
-
235
- message.cols.push(reader.string());
236
- continue;
237
- case 2:
238
- if (tag != 18) {
239
- break;
240
- }
241
-
242
- message.rows.push(Row.decode(reader, reader.uint32()));
243
- continue;
244
- case 3:
245
- if (tag != 26) {
246
- break;
247
- }
248
-
249
- message.types.push(reader.string());
250
- continue;
251
- }
252
- if ((tag & 7) == 4 || tag == 0) {
253
- break;
254
- }
255
- reader.skipType(tag & 7);
256
- }
257
- return message;
258
- },
259
-
260
- create(base?: DeepPartial<GenericTable>): GenericTable {
261
- return GenericTable.fromPartial(base ?? {});
262
- },
263
-
264
- fromPartial(object: DeepPartial<GenericTable>): GenericTable {
265
- const message = createBaseGenericTable();
266
- message.cols = object.cols?.map((e) => e) || [];
267
- message.rows = object.rows?.map((e) => Row.fromPartial(e)) || [];
268
- message.types = object.types?.map((e) => e) || [];
269
- return message;
270
- },
271
- };
272
-
273
- function createBaseQueryLayerResponse(): QueryLayerResponse {
274
- return { tables: {} };
275
- }
276
-
277
- export const QueryLayerResponse = {
278
- encode(message: QueryLayerResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
279
- Object.entries(message.tables).forEach(([key, value]) => {
280
- QueryLayerResponse_TablesEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).ldelim();
281
- });
282
- return writer;
283
- },
284
-
285
- decode(input: _m0.Reader | Uint8Array, length?: number): QueryLayerResponse {
286
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
287
- let end = length === undefined ? reader.len : reader.pos + length;
288
- const message = createBaseQueryLayerResponse();
289
- while (reader.pos < end) {
290
- const tag = reader.uint32();
291
- switch (tag >>> 3) {
292
- case 1:
293
- if (tag != 10) {
294
- break;
295
- }
296
-
297
- const entry1 = QueryLayerResponse_TablesEntry.decode(reader, reader.uint32());
298
- if (entry1.value !== undefined) {
299
- message.tables[entry1.key] = entry1.value;
300
- }
301
- continue;
302
- }
303
- if ((tag & 7) == 4 || tag == 0) {
304
- break;
305
- }
306
- reader.skipType(tag & 7);
307
- }
308
- return message;
309
- },
310
-
311
- create(base?: DeepPartial<QueryLayerResponse>): QueryLayerResponse {
312
- return QueryLayerResponse.fromPartial(base ?? {});
313
- },
314
-
315
- fromPartial(object: DeepPartial<QueryLayerResponse>): QueryLayerResponse {
316
- const message = createBaseQueryLayerResponse();
317
- message.tables = Object.entries(object.tables ?? {}).reduce<{ [key: string]: GenericTable }>(
318
- (acc, [key, value]) => {
319
- if (value !== undefined) {
320
- acc[key] = GenericTable.fromPartial(value);
321
- }
322
- return acc;
323
- },
324
- {}
325
- );
326
- return message;
327
- },
328
- };
329
-
330
- function createBaseQueryLayerResponse_TablesEntry(): QueryLayerResponse_TablesEntry {
331
- return { key: "", value: undefined };
332
- }
333
-
334
- export const QueryLayerResponse_TablesEntry = {
335
- encode(message: QueryLayerResponse_TablesEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
336
- if (message.key !== "") {
337
- writer.uint32(10).string(message.key);
338
- }
339
- if (message.value !== undefined) {
340
- GenericTable.encode(message.value, writer.uint32(18).fork()).ldelim();
341
- }
342
- return writer;
343
- },
344
-
345
- decode(input: _m0.Reader | Uint8Array, length?: number): QueryLayerResponse_TablesEntry {
346
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
347
- let end = length === undefined ? reader.len : reader.pos + length;
348
- const message = createBaseQueryLayerResponse_TablesEntry();
349
- while (reader.pos < end) {
350
- const tag = reader.uint32();
351
- switch (tag >>> 3) {
352
- case 1:
353
- if (tag != 10) {
354
- break;
355
- }
356
-
357
- message.key = reader.string();
358
- continue;
359
- case 2:
360
- if (tag != 18) {
361
- break;
362
- }
363
-
364
- message.value = GenericTable.decode(reader, reader.uint32());
365
- continue;
366
- }
367
- if ((tag & 7) == 4 || tag == 0) {
368
- break;
369
- }
370
- reader.skipType(tag & 7);
371
- }
372
- return message;
373
- },
374
-
375
- create(base?: DeepPartial<QueryLayerResponse_TablesEntry>): QueryLayerResponse_TablesEntry {
376
- return QueryLayerResponse_TablesEntry.fromPartial(base ?? {});
377
- },
378
-
379
- fromPartial(object: DeepPartial<QueryLayerResponse_TablesEntry>): QueryLayerResponse_TablesEntry {
380
- const message = createBaseQueryLayerResponse_TablesEntry();
381
- message.key = object.key ?? "";
382
- message.value =
383
- object.value !== undefined && object.value !== null ? GenericTable.fromPartial(object.value) : undefined;
384
- return message;
385
- },
386
- };
387
-
388
- function createBaseQueryLayerStateResponse(): QueryLayerStateResponse {
389
- return { chainTables: {}, worldTables: {} };
390
- }
391
-
392
- export const QueryLayerStateResponse = {
393
- encode(message: QueryLayerStateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
394
- Object.entries(message.chainTables).forEach(([key, value]) => {
395
- QueryLayerStateResponse_ChainTablesEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).ldelim();
396
- });
397
- Object.entries(message.worldTables).forEach(([key, value]) => {
398
- QueryLayerStateResponse_WorldTablesEntry.encode({ key: key as any, value }, writer.uint32(18).fork()).ldelim();
399
- });
400
- return writer;
401
- },
402
-
403
- decode(input: _m0.Reader | Uint8Array, length?: number): QueryLayerStateResponse {
404
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
405
- let end = length === undefined ? reader.len : reader.pos + length;
406
- const message = createBaseQueryLayerStateResponse();
407
- while (reader.pos < end) {
408
- const tag = reader.uint32();
409
- switch (tag >>> 3) {
410
- case 1:
411
- if (tag != 10) {
412
- break;
413
- }
414
-
415
- const entry1 = QueryLayerStateResponse_ChainTablesEntry.decode(reader, reader.uint32());
416
- if (entry1.value !== undefined) {
417
- message.chainTables[entry1.key] = entry1.value;
418
- }
419
- continue;
420
- case 2:
421
- if (tag != 18) {
422
- break;
423
- }
424
-
425
- const entry2 = QueryLayerStateResponse_WorldTablesEntry.decode(reader, reader.uint32());
426
- if (entry2.value !== undefined) {
427
- message.worldTables[entry2.key] = entry2.value;
428
- }
429
- continue;
430
- }
431
- if ((tag & 7) == 4 || tag == 0) {
432
- break;
433
- }
434
- reader.skipType(tag & 7);
435
- }
436
- return message;
437
- },
438
-
439
- create(base?: DeepPartial<QueryLayerStateResponse>): QueryLayerStateResponse {
440
- return QueryLayerStateResponse.fromPartial(base ?? {});
441
- },
442
-
443
- fromPartial(object: DeepPartial<QueryLayerStateResponse>): QueryLayerStateResponse {
444
- const message = createBaseQueryLayerStateResponse();
445
- message.chainTables = Object.entries(object.chainTables ?? {}).reduce<{ [key: string]: GenericTable }>(
446
- (acc, [key, value]) => {
447
- if (value !== undefined) {
448
- acc[key] = GenericTable.fromPartial(value);
449
- }
450
- return acc;
451
- },
452
- {}
453
- );
454
- message.worldTables = Object.entries(object.worldTables ?? {}).reduce<{ [key: string]: GenericTable }>(
455
- (acc, [key, value]) => {
456
- if (value !== undefined) {
457
- acc[key] = GenericTable.fromPartial(value);
458
- }
459
- return acc;
460
- },
461
- {}
462
- );
463
- return message;
464
- },
465
- };
466
-
467
- function createBaseQueryLayerStateResponse_ChainTablesEntry(): QueryLayerStateResponse_ChainTablesEntry {
468
- return { key: "", value: undefined };
469
- }
470
-
471
- export const QueryLayerStateResponse_ChainTablesEntry = {
472
- encode(message: QueryLayerStateResponse_ChainTablesEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
473
- if (message.key !== "") {
474
- writer.uint32(10).string(message.key);
475
- }
476
- if (message.value !== undefined) {
477
- GenericTable.encode(message.value, writer.uint32(18).fork()).ldelim();
478
- }
479
- return writer;
480
- },
481
-
482
- decode(input: _m0.Reader | Uint8Array, length?: number): QueryLayerStateResponse_ChainTablesEntry {
483
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
484
- let end = length === undefined ? reader.len : reader.pos + length;
485
- const message = createBaseQueryLayerStateResponse_ChainTablesEntry();
486
- while (reader.pos < end) {
487
- const tag = reader.uint32();
488
- switch (tag >>> 3) {
489
- case 1:
490
- if (tag != 10) {
491
- break;
492
- }
493
-
494
- message.key = reader.string();
495
- continue;
496
- case 2:
497
- if (tag != 18) {
498
- break;
499
- }
500
-
501
- message.value = GenericTable.decode(reader, reader.uint32());
502
- continue;
503
- }
504
- if ((tag & 7) == 4 || tag == 0) {
505
- break;
506
- }
507
- reader.skipType(tag & 7);
508
- }
509
- return message;
510
- },
511
-
512
- create(base?: DeepPartial<QueryLayerStateResponse_ChainTablesEntry>): QueryLayerStateResponse_ChainTablesEntry {
513
- return QueryLayerStateResponse_ChainTablesEntry.fromPartial(base ?? {});
514
- },
515
-
516
- fromPartial(object: DeepPartial<QueryLayerStateResponse_ChainTablesEntry>): QueryLayerStateResponse_ChainTablesEntry {
517
- const message = createBaseQueryLayerStateResponse_ChainTablesEntry();
518
- message.key = object.key ?? "";
519
- message.value =
520
- object.value !== undefined && object.value !== null ? GenericTable.fromPartial(object.value) : undefined;
521
- return message;
522
- },
523
- };
524
-
525
- function createBaseQueryLayerStateResponse_WorldTablesEntry(): QueryLayerStateResponse_WorldTablesEntry {
526
- return { key: "", value: undefined };
527
- }
528
-
529
- export const QueryLayerStateResponse_WorldTablesEntry = {
530
- encode(message: QueryLayerStateResponse_WorldTablesEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
531
- if (message.key !== "") {
532
- writer.uint32(10).string(message.key);
533
- }
534
- if (message.value !== undefined) {
535
- GenericTable.encode(message.value, writer.uint32(18).fork()).ldelim();
536
- }
537
- return writer;
538
- },
539
-
540
- decode(input: _m0.Reader | Uint8Array, length?: number): QueryLayerStateResponse_WorldTablesEntry {
541
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
542
- let end = length === undefined ? reader.len : reader.pos + length;
543
- const message = createBaseQueryLayerStateResponse_WorldTablesEntry();
544
- while (reader.pos < end) {
545
- const tag = reader.uint32();
546
- switch (tag >>> 3) {
547
- case 1:
548
- if (tag != 10) {
549
- break;
550
- }
551
-
552
- message.key = reader.string();
553
- continue;
554
- case 2:
555
- if (tag != 18) {
556
- break;
557
- }
558
-
559
- message.value = GenericTable.decode(reader, reader.uint32());
560
- continue;
561
- }
562
- if ((tag & 7) == 4 || tag == 0) {
563
- break;
564
- }
565
- reader.skipType(tag & 7);
566
- }
567
- return message;
568
- },
569
-
570
- create(base?: DeepPartial<QueryLayerStateResponse_WorldTablesEntry>): QueryLayerStateResponse_WorldTablesEntry {
571
- return QueryLayerStateResponse_WorldTablesEntry.fromPartial(base ?? {});
572
- },
573
-
574
- fromPartial(object: DeepPartial<QueryLayerStateResponse_WorldTablesEntry>): QueryLayerStateResponse_WorldTablesEntry {
575
- const message = createBaseQueryLayerStateResponse_WorldTablesEntry();
576
- message.key = object.key ?? "";
577
- message.value =
578
- object.value !== undefined && object.value !== null ? GenericTable.fromPartial(object.value) : undefined;
579
- return message;
580
- },
581
- };
582
-
583
- function createBaseQueryLayerStateStreamResponse(): QueryLayerStateStreamResponse {
584
- return { inserted: undefined, updated: undefined, deleted: undefined };
585
- }
586
-
587
- export const QueryLayerStateStreamResponse = {
588
- encode(message: QueryLayerStateStreamResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
589
- if (message.inserted !== undefined) {
590
- QueryLayerStateResponse.encode(message.inserted, writer.uint32(10).fork()).ldelim();
591
- }
592
- if (message.updated !== undefined) {
593
- QueryLayerStateResponse.encode(message.updated, writer.uint32(18).fork()).ldelim();
594
- }
595
- if (message.deleted !== undefined) {
596
- QueryLayerStateResponse.encode(message.deleted, writer.uint32(26).fork()).ldelim();
597
- }
598
- return writer;
599
- },
600
-
601
- decode(input: _m0.Reader | Uint8Array, length?: number): QueryLayerStateStreamResponse {
602
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
603
- let end = length === undefined ? reader.len : reader.pos + length;
604
- const message = createBaseQueryLayerStateStreamResponse();
605
- while (reader.pos < end) {
606
- const tag = reader.uint32();
607
- switch (tag >>> 3) {
608
- case 1:
609
- if (tag != 10) {
610
- break;
611
- }
612
-
613
- message.inserted = QueryLayerStateResponse.decode(reader, reader.uint32());
614
- continue;
615
- case 2:
616
- if (tag != 18) {
617
- break;
618
- }
619
-
620
- message.updated = QueryLayerStateResponse.decode(reader, reader.uint32());
621
- continue;
622
- case 3:
623
- if (tag != 26) {
624
- break;
625
- }
626
-
627
- message.deleted = QueryLayerStateResponse.decode(reader, reader.uint32());
628
- continue;
629
- }
630
- if ((tag & 7) == 4 || tag == 0) {
631
- break;
632
- }
633
- reader.skipType(tag & 7);
634
- }
635
- return message;
636
- },
637
-
638
- create(base?: DeepPartial<QueryLayerStateStreamResponse>): QueryLayerStateStreamResponse {
639
- return QueryLayerStateStreamResponse.fromPartial(base ?? {});
640
- },
641
-
642
- fromPartial(object: DeepPartial<QueryLayerStateStreamResponse>): QueryLayerStateStreamResponse {
643
- const message = createBaseQueryLayerStateStreamResponse();
644
- message.inserted =
645
- object.inserted !== undefined && object.inserted !== null
646
- ? QueryLayerStateResponse.fromPartial(object.inserted)
647
- : undefined;
648
- message.updated =
649
- object.updated !== undefined && object.updated !== null
650
- ? QueryLayerStateResponse.fromPartial(object.updated)
651
- : undefined;
652
- message.deleted =
653
- object.deleted !== undefined && object.deleted !== null
654
- ? QueryLayerStateResponse.fromPartial(object.deleted)
655
- : undefined;
656
- return message;
657
- },
658
- };
659
-
660
- function createBaseNamespace(): Namespace {
661
- return { chainId: "", worldAddress: "" };
662
- }
663
-
664
- export const Namespace = {
665
- encode(message: Namespace, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
666
- if (message.chainId !== "") {
667
- writer.uint32(10).string(message.chainId);
668
- }
669
- if (message.worldAddress !== "") {
670
- writer.uint32(18).string(message.worldAddress);
671
- }
672
- return writer;
673
- },
674
-
675
- decode(input: _m0.Reader | Uint8Array, length?: number): Namespace {
676
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
677
- let end = length === undefined ? reader.len : reader.pos + length;
678
- const message = createBaseNamespace();
679
- while (reader.pos < end) {
680
- const tag = reader.uint32();
681
- switch (tag >>> 3) {
682
- case 1:
683
- if (tag != 10) {
684
- break;
685
- }
686
-
687
- message.chainId = reader.string();
688
- continue;
689
- case 2:
690
- if (tag != 18) {
691
- break;
692
- }
693
-
694
- message.worldAddress = reader.string();
695
- continue;
696
- }
697
- if ((tag & 7) == 4 || tag == 0) {
698
- break;
699
- }
700
- reader.skipType(tag & 7);
701
- }
702
- return message;
703
- },
704
-
705
- create(base?: DeepPartial<Namespace>): Namespace {
706
- return Namespace.fromPartial(base ?? {});
707
- },
708
-
709
- fromPartial(object: DeepPartial<Namespace>): Namespace {
710
- const message = createBaseNamespace();
711
- message.chainId = object.chainId ?? "";
712
- message.worldAddress = object.worldAddress ?? "";
713
- return message;
714
- },
715
- };
716
-
717
- function createBaseStateRequest(): StateRequest {
718
- return { namespace: undefined, worldTables: [], chainTables: [] };
719
- }
720
-
721
- export const StateRequest = {
722
- encode(message: StateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
723
- if (message.namespace !== undefined) {
724
- Namespace.encode(message.namespace, writer.uint32(10).fork()).ldelim();
725
- }
726
- for (const v of message.worldTables) {
727
- writer.uint32(18).string(v!);
728
- }
729
- for (const v of message.chainTables) {
730
- writer.uint32(26).string(v!);
731
- }
732
- return writer;
733
- },
734
-
735
- decode(input: _m0.Reader | Uint8Array, length?: number): StateRequest {
736
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
737
- let end = length === undefined ? reader.len : reader.pos + length;
738
- const message = createBaseStateRequest();
739
- while (reader.pos < end) {
740
- const tag = reader.uint32();
741
- switch (tag >>> 3) {
742
- case 1:
743
- if (tag != 10) {
744
- break;
745
- }
746
-
747
- message.namespace = Namespace.decode(reader, reader.uint32());
748
- continue;
749
- case 2:
750
- if (tag != 18) {
751
- break;
752
- }
753
-
754
- message.worldTables.push(reader.string());
755
- continue;
756
- case 3:
757
- if (tag != 26) {
758
- break;
759
- }
760
-
761
- message.chainTables.push(reader.string());
762
- continue;
763
- }
764
- if ((tag & 7) == 4 || tag == 0) {
765
- break;
766
- }
767
- reader.skipType(tag & 7);
768
- }
769
- return message;
770
- },
771
-
772
- create(base?: DeepPartial<StateRequest>): StateRequest {
773
- return StateRequest.fromPartial(base ?? {});
774
- },
775
-
776
- fromPartial(object: DeepPartial<StateRequest>): StateRequest {
777
- const message = createBaseStateRequest();
778
- message.namespace =
779
- object.namespace !== undefined && object.namespace !== null ? Namespace.fromPartial(object.namespace) : undefined;
780
- message.worldTables = object.worldTables?.map((e) => e) || [];
781
- message.chainTables = object.chainTables?.map((e) => e) || [];
782
- return message;
783
- },
784
- };
785
-
786
- function createBaseSingleStateRequest(): SingleStateRequest {
787
- return { namespace: undefined, table: "", filter: [], project: [] };
788
- }
789
-
790
- export const SingleStateRequest = {
791
- encode(message: SingleStateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
792
- if (message.namespace !== undefined) {
793
- Namespace.encode(message.namespace, writer.uint32(10).fork()).ldelim();
794
- }
795
- if (message.table !== "") {
796
- writer.uint32(18).string(message.table);
797
- }
798
- for (const v of message.filter) {
799
- Filter.encode(v!, writer.uint32(26).fork()).ldelim();
800
- }
801
- for (const v of message.project) {
802
- ProjectedField.encode(v!, writer.uint32(34).fork()).ldelim();
803
- }
804
- return writer;
805
- },
806
-
807
- decode(input: _m0.Reader | Uint8Array, length?: number): SingleStateRequest {
808
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
809
- let end = length === undefined ? reader.len : reader.pos + length;
810
- const message = createBaseSingleStateRequest();
811
- while (reader.pos < end) {
812
- const tag = reader.uint32();
813
- switch (tag >>> 3) {
814
- case 1:
815
- if (tag != 10) {
816
- break;
817
- }
818
-
819
- message.namespace = Namespace.decode(reader, reader.uint32());
820
- continue;
821
- case 2:
822
- if (tag != 18) {
823
- break;
824
- }
825
-
826
- message.table = reader.string();
827
- continue;
828
- case 3:
829
- if (tag != 26) {
830
- break;
831
- }
832
-
833
- message.filter.push(Filter.decode(reader, reader.uint32()));
834
- continue;
835
- case 4:
836
- if (tag != 34) {
837
- break;
838
- }
839
-
840
- message.project.push(ProjectedField.decode(reader, reader.uint32()));
841
- continue;
842
- }
843
- if ((tag & 7) == 4 || tag == 0) {
844
- break;
845
- }
846
- reader.skipType(tag & 7);
847
- }
848
- return message;
849
- },
850
-
851
- create(base?: DeepPartial<SingleStateRequest>): SingleStateRequest {
852
- return SingleStateRequest.fromPartial(base ?? {});
853
- },
854
-
855
- fromPartial(object: DeepPartial<SingleStateRequest>): SingleStateRequest {
856
- const message = createBaseSingleStateRequest();
857
- message.namespace =
858
- object.namespace !== undefined && object.namespace !== null ? Namespace.fromPartial(object.namespace) : undefined;
859
- message.table = object.table ?? "";
860
- message.filter = object.filter?.map((e) => Filter.fromPartial(e)) || [];
861
- message.project = object.project?.map((e) => ProjectedField.fromPartial(e)) || [];
862
- return message;
863
- },
864
- };
865
-
866
- function createBaseFindRequest(): FindRequest {
867
- return { from: "", filter: [], project: [], namespace: undefined, options: undefined };
868
- }
869
-
870
- export const FindRequest = {
871
- encode(message: FindRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
872
- if (message.from !== "") {
873
- writer.uint32(10).string(message.from);
874
- }
875
- for (const v of message.filter) {
876
- Filter.encode(v!, writer.uint32(18).fork()).ldelim();
877
- }
878
- for (const v of message.project) {
879
- ProjectedField.encode(v!, writer.uint32(26).fork()).ldelim();
880
- }
881
- if (message.namespace !== undefined) {
882
- Namespace.encode(message.namespace, writer.uint32(34).fork()).ldelim();
883
- }
884
- if (message.options !== undefined) {
885
- FindRequestOptions.encode(message.options, writer.uint32(42).fork()).ldelim();
886
- }
887
- return writer;
888
- },
889
-
890
- decode(input: _m0.Reader | Uint8Array, length?: number): FindRequest {
891
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
892
- let end = length === undefined ? reader.len : reader.pos + length;
893
- const message = createBaseFindRequest();
894
- while (reader.pos < end) {
895
- const tag = reader.uint32();
896
- switch (tag >>> 3) {
897
- case 1:
898
- if (tag != 10) {
899
- break;
900
- }
901
-
902
- message.from = reader.string();
903
- continue;
904
- case 2:
905
- if (tag != 18) {
906
- break;
907
- }
908
-
909
- message.filter.push(Filter.decode(reader, reader.uint32()));
910
- continue;
911
- case 3:
912
- if (tag != 26) {
913
- break;
914
- }
915
-
916
- message.project.push(ProjectedField.decode(reader, reader.uint32()));
917
- continue;
918
- case 4:
919
- if (tag != 34) {
920
- break;
921
- }
922
-
923
- message.namespace = Namespace.decode(reader, reader.uint32());
924
- continue;
925
- case 5:
926
- if (tag != 42) {
927
- break;
928
- }
929
-
930
- message.options = FindRequestOptions.decode(reader, reader.uint32());
931
- continue;
932
- }
933
- if ((tag & 7) == 4 || tag == 0) {
934
- break;
935
- }
936
- reader.skipType(tag & 7);
937
- }
938
- return message;
939
- },
940
-
941
- create(base?: DeepPartial<FindRequest>): FindRequest {
942
- return FindRequest.fromPartial(base ?? {});
943
- },
944
-
945
- fromPartial(object: DeepPartial<FindRequest>): FindRequest {
946
- const message = createBaseFindRequest();
947
- message.from = object.from ?? "";
948
- message.filter = object.filter?.map((e) => Filter.fromPartial(e)) || [];
949
- message.project = object.project?.map((e) => ProjectedField.fromPartial(e)) || [];
950
- message.namespace =
951
- object.namespace !== undefined && object.namespace !== null ? Namespace.fromPartial(object.namespace) : undefined;
952
- message.options =
953
- object.options !== undefined && object.options !== null
954
- ? FindRequestOptions.fromPartial(object.options)
955
- : undefined;
956
- return message;
957
- },
958
- };
959
-
960
- function createBaseFindAllRequest(): FindAllRequest {
961
- return { tables: [], namespace: undefined, options: undefined };
962
- }
963
-
964
- export const FindAllRequest = {
965
- encode(message: FindAllRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
966
- for (const v of message.tables) {
967
- writer.uint32(10).string(v!);
968
- }
969
- if (message.namespace !== undefined) {
970
- Namespace.encode(message.namespace, writer.uint32(18).fork()).ldelim();
971
- }
972
- if (message.options !== undefined) {
973
- FindRequestOptions.encode(message.options, writer.uint32(26).fork()).ldelim();
974
- }
975
- return writer;
976
- },
977
-
978
- decode(input: _m0.Reader | Uint8Array, length?: number): FindAllRequest {
979
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
980
- let end = length === undefined ? reader.len : reader.pos + length;
981
- const message = createBaseFindAllRequest();
982
- while (reader.pos < end) {
983
- const tag = reader.uint32();
984
- switch (tag >>> 3) {
985
- case 1:
986
- if (tag != 10) {
987
- break;
988
- }
989
-
990
- message.tables.push(reader.string());
991
- continue;
992
- case 2:
993
- if (tag != 18) {
994
- break;
995
- }
996
-
997
- message.namespace = Namespace.decode(reader, reader.uint32());
998
- continue;
999
- case 3:
1000
- if (tag != 26) {
1001
- break;
1002
- }
1003
-
1004
- message.options = FindRequestOptions.decode(reader, reader.uint32());
1005
- continue;
1006
- }
1007
- if ((tag & 7) == 4 || tag == 0) {
1008
- break;
1009
- }
1010
- reader.skipType(tag & 7);
1011
- }
1012
- return message;
1013
- },
1014
-
1015
- create(base?: DeepPartial<FindAllRequest>): FindAllRequest {
1016
- return FindAllRequest.fromPartial(base ?? {});
1017
- },
1018
-
1019
- fromPartial(object: DeepPartial<FindAllRequest>): FindAllRequest {
1020
- const message = createBaseFindAllRequest();
1021
- message.tables = object.tables?.map((e) => e) || [];
1022
- message.namespace =
1023
- object.namespace !== undefined && object.namespace !== null ? Namespace.fromPartial(object.namespace) : undefined;
1024
- message.options =
1025
- object.options !== undefined && object.options !== null
1026
- ? FindRequestOptions.fromPartial(object.options)
1027
- : undefined;
1028
- return message;
1029
- },
1030
- };
1031
-
1032
- function createBaseJoinRequest(): JoinRequest {
1033
- return { on: undefined, children: [], namespace: undefined };
1034
- }
1035
-
1036
- export const JoinRequest = {
1037
- encode(message: JoinRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1038
- if (message.on !== undefined) {
1039
- FieldPair.encode(message.on, writer.uint32(10).fork()).ldelim();
1040
- }
1041
- for (const v of message.children) {
1042
- FindRequest.encode(v!, writer.uint32(18).fork()).ldelim();
1043
- }
1044
- if (message.namespace !== undefined) {
1045
- Namespace.encode(message.namespace, writer.uint32(26).fork()).ldelim();
1046
- }
1047
- return writer;
1048
- },
1049
-
1050
- decode(input: _m0.Reader | Uint8Array, length?: number): JoinRequest {
1051
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1052
- let end = length === undefined ? reader.len : reader.pos + length;
1053
- const message = createBaseJoinRequest();
1054
- while (reader.pos < end) {
1055
- const tag = reader.uint32();
1056
- switch (tag >>> 3) {
1057
- case 1:
1058
- if (tag != 10) {
1059
- break;
1060
- }
1061
-
1062
- message.on = FieldPair.decode(reader, reader.uint32());
1063
- continue;
1064
- case 2:
1065
- if (tag != 18) {
1066
- break;
1067
- }
1068
-
1069
- message.children.push(FindRequest.decode(reader, reader.uint32()));
1070
- continue;
1071
- case 3:
1072
- if (tag != 26) {
1073
- break;
1074
- }
1075
-
1076
- message.namespace = Namespace.decode(reader, reader.uint32());
1077
- continue;
1078
- }
1079
- if ((tag & 7) == 4 || tag == 0) {
1080
- break;
1081
- }
1082
- reader.skipType(tag & 7);
1083
- }
1084
- return message;
1085
- },
1086
-
1087
- create(base?: DeepPartial<JoinRequest>): JoinRequest {
1088
- return JoinRequest.fromPartial(base ?? {});
1089
- },
1090
-
1091
- fromPartial(object: DeepPartial<JoinRequest>): JoinRequest {
1092
- const message = createBaseJoinRequest();
1093
- message.on = object.on !== undefined && object.on !== null ? FieldPair.fromPartial(object.on) : undefined;
1094
- message.children = object.children?.map((e) => FindRequest.fromPartial(e)) || [];
1095
- message.namespace =
1096
- object.namespace !== undefined && object.namespace !== null ? Namespace.fromPartial(object.namespace) : undefined;
1097
- return message;
1098
- },
1099
- };
1100
-
1101
- function createBaseDeleteRequest(): DeleteRequest {
1102
- return { from: "", filter: [] };
1103
- }
1104
-
1105
- export const DeleteRequest = {
1106
- encode(message: DeleteRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1107
- if (message.from !== "") {
1108
- writer.uint32(10).string(message.from);
1109
- }
1110
- for (const v of message.filter) {
1111
- Filter.encode(v!, writer.uint32(18).fork()).ldelim();
1112
- }
1113
- return writer;
1114
- },
1115
-
1116
- decode(input: _m0.Reader | Uint8Array, length?: number): DeleteRequest {
1117
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1118
- let end = length === undefined ? reader.len : reader.pos + length;
1119
- const message = createBaseDeleteRequest();
1120
- while (reader.pos < end) {
1121
- const tag = reader.uint32();
1122
- switch (tag >>> 3) {
1123
- case 1:
1124
- if (tag != 10) {
1125
- break;
1126
- }
1127
-
1128
- message.from = reader.string();
1129
- continue;
1130
- case 2:
1131
- if (tag != 18) {
1132
- break;
1133
- }
1134
-
1135
- message.filter.push(Filter.decode(reader, reader.uint32()));
1136
- continue;
1137
- }
1138
- if ((tag & 7) == 4 || tag == 0) {
1139
- break;
1140
- }
1141
- reader.skipType(tag & 7);
1142
- }
1143
- return message;
1144
- },
1145
-
1146
- create(base?: DeepPartial<DeleteRequest>): DeleteRequest {
1147
- return DeleteRequest.fromPartial(base ?? {});
1148
- },
1149
-
1150
- fromPartial(object: DeepPartial<DeleteRequest>): DeleteRequest {
1151
- const message = createBaseDeleteRequest();
1152
- message.from = object.from ?? "";
1153
- message.filter = object.filter?.map((e) => Filter.fromPartial(e)) || [];
1154
- return message;
1155
- },
1156
- };
1157
-
1158
- function createBaseUpdateRequest(): UpdateRequest {
1159
- return { target: "", filter: [], row: {} };
1160
- }
1161
-
1162
- export const UpdateRequest = {
1163
- encode(message: UpdateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1164
- if (message.target !== "") {
1165
- writer.uint32(10).string(message.target);
1166
- }
1167
- for (const v of message.filter) {
1168
- Filter.encode(v!, writer.uint32(18).fork()).ldelim();
1169
- }
1170
- Object.entries(message.row).forEach(([key, value]) => {
1171
- UpdateRequest_RowEntry.encode({ key: key as any, value }, writer.uint32(26).fork()).ldelim();
1172
- });
1173
- return writer;
1174
- },
1175
-
1176
- decode(input: _m0.Reader | Uint8Array, length?: number): UpdateRequest {
1177
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1178
- let end = length === undefined ? reader.len : reader.pos + length;
1179
- const message = createBaseUpdateRequest();
1180
- while (reader.pos < end) {
1181
- const tag = reader.uint32();
1182
- switch (tag >>> 3) {
1183
- case 1:
1184
- if (tag != 10) {
1185
- break;
1186
- }
1187
-
1188
- message.target = reader.string();
1189
- continue;
1190
- case 2:
1191
- if (tag != 18) {
1192
- break;
1193
- }
1194
-
1195
- message.filter.push(Filter.decode(reader, reader.uint32()));
1196
- continue;
1197
- case 3:
1198
- if (tag != 26) {
1199
- break;
1200
- }
1201
-
1202
- const entry3 = UpdateRequest_RowEntry.decode(reader, reader.uint32());
1203
- if (entry3.value !== undefined) {
1204
- message.row[entry3.key] = entry3.value;
1205
- }
1206
- continue;
1207
- }
1208
- if ((tag & 7) == 4 || tag == 0) {
1209
- break;
1210
- }
1211
- reader.skipType(tag & 7);
1212
- }
1213
- return message;
1214
- },
1215
-
1216
- create(base?: DeepPartial<UpdateRequest>): UpdateRequest {
1217
- return UpdateRequest.fromPartial(base ?? {});
1218
- },
1219
-
1220
- fromPartial(object: DeepPartial<UpdateRequest>): UpdateRequest {
1221
- const message = createBaseUpdateRequest();
1222
- message.target = object.target ?? "";
1223
- message.filter = object.filter?.map((e) => Filter.fromPartial(e)) || [];
1224
- message.row = Object.entries(object.row ?? {}).reduce<{ [key: string]: string }>((acc, [key, value]) => {
1225
- if (value !== undefined) {
1226
- acc[key] = String(value);
1227
- }
1228
- return acc;
1229
- }, {});
1230
- return message;
1231
- },
1232
- };
1233
-
1234
- function createBaseUpdateRequest_RowEntry(): UpdateRequest_RowEntry {
1235
- return { key: "", value: "" };
1236
- }
1237
-
1238
- export const UpdateRequest_RowEntry = {
1239
- encode(message: UpdateRequest_RowEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1240
- if (message.key !== "") {
1241
- writer.uint32(10).string(message.key);
1242
- }
1243
- if (message.value !== "") {
1244
- writer.uint32(18).string(message.value);
1245
- }
1246
- return writer;
1247
- },
1248
-
1249
- decode(input: _m0.Reader | Uint8Array, length?: number): UpdateRequest_RowEntry {
1250
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1251
- let end = length === undefined ? reader.len : reader.pos + length;
1252
- const message = createBaseUpdateRequest_RowEntry();
1253
- while (reader.pos < end) {
1254
- const tag = reader.uint32();
1255
- switch (tag >>> 3) {
1256
- case 1:
1257
- if (tag != 10) {
1258
- break;
1259
- }
1260
-
1261
- message.key = reader.string();
1262
- continue;
1263
- case 2:
1264
- if (tag != 18) {
1265
- break;
1266
- }
1267
-
1268
- message.value = reader.string();
1269
- continue;
1270
- }
1271
- if ((tag & 7) == 4 || tag == 0) {
1272
- break;
1273
- }
1274
- reader.skipType(tag & 7);
1275
- }
1276
- return message;
1277
- },
1278
-
1279
- create(base?: DeepPartial<UpdateRequest_RowEntry>): UpdateRequest_RowEntry {
1280
- return UpdateRequest_RowEntry.fromPartial(base ?? {});
1281
- },
1282
-
1283
- fromPartial(object: DeepPartial<UpdateRequest_RowEntry>): UpdateRequest_RowEntry {
1284
- const message = createBaseUpdateRequest_RowEntry();
1285
- message.key = object.key ?? "";
1286
- message.value = object.value ?? "";
1287
- return message;
1288
- },
1289
- };
1290
-
1291
- function createBaseInsertRequest(): InsertRequest {
1292
- return { into: "", row: {} };
1293
- }
1294
-
1295
- export const InsertRequest = {
1296
- encode(message: InsertRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1297
- if (message.into !== "") {
1298
- writer.uint32(10).string(message.into);
1299
- }
1300
- Object.entries(message.row).forEach(([key, value]) => {
1301
- InsertRequest_RowEntry.encode({ key: key as any, value }, writer.uint32(26).fork()).ldelim();
1302
- });
1303
- return writer;
1304
- },
1305
-
1306
- decode(input: _m0.Reader | Uint8Array, length?: number): InsertRequest {
1307
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1308
- let end = length === undefined ? reader.len : reader.pos + length;
1309
- const message = createBaseInsertRequest();
1310
- while (reader.pos < end) {
1311
- const tag = reader.uint32();
1312
- switch (tag >>> 3) {
1313
- case 1:
1314
- if (tag != 10) {
1315
- break;
1316
- }
1317
-
1318
- message.into = reader.string();
1319
- continue;
1320
- case 3:
1321
- if (tag != 26) {
1322
- break;
1323
- }
1324
-
1325
- const entry3 = InsertRequest_RowEntry.decode(reader, reader.uint32());
1326
- if (entry3.value !== undefined) {
1327
- message.row[entry3.key] = entry3.value;
1328
- }
1329
- continue;
1330
- }
1331
- if ((tag & 7) == 4 || tag == 0) {
1332
- break;
1333
- }
1334
- reader.skipType(tag & 7);
1335
- }
1336
- return message;
1337
- },
1338
-
1339
- create(base?: DeepPartial<InsertRequest>): InsertRequest {
1340
- return InsertRequest.fromPartial(base ?? {});
1341
- },
1342
-
1343
- fromPartial(object: DeepPartial<InsertRequest>): InsertRequest {
1344
- const message = createBaseInsertRequest();
1345
- message.into = object.into ?? "";
1346
- message.row = Object.entries(object.row ?? {}).reduce<{ [key: string]: string }>((acc, [key, value]) => {
1347
- if (value !== undefined) {
1348
- acc[key] = String(value);
1349
- }
1350
- return acc;
1351
- }, {});
1352
- return message;
1353
- },
1354
- };
1355
-
1356
- function createBaseInsertRequest_RowEntry(): InsertRequest_RowEntry {
1357
- return { key: "", value: "" };
1358
- }
1359
-
1360
- export const InsertRequest_RowEntry = {
1361
- encode(message: InsertRequest_RowEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1362
- if (message.key !== "") {
1363
- writer.uint32(10).string(message.key);
1364
- }
1365
- if (message.value !== "") {
1366
- writer.uint32(18).string(message.value);
1367
- }
1368
- return writer;
1369
- },
1370
-
1371
- decode(input: _m0.Reader | Uint8Array, length?: number): InsertRequest_RowEntry {
1372
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1373
- let end = length === undefined ? reader.len : reader.pos + length;
1374
- const message = createBaseInsertRequest_RowEntry();
1375
- while (reader.pos < end) {
1376
- const tag = reader.uint32();
1377
- switch (tag >>> 3) {
1378
- case 1:
1379
- if (tag != 10) {
1380
- break;
1381
- }
1382
-
1383
- message.key = reader.string();
1384
- continue;
1385
- case 2:
1386
- if (tag != 18) {
1387
- break;
1388
- }
1389
-
1390
- message.value = reader.string();
1391
- continue;
1392
- }
1393
- if ((tag & 7) == 4 || tag == 0) {
1394
- break;
1395
- }
1396
- reader.skipType(tag & 7);
1397
- }
1398
- return message;
1399
- },
1400
-
1401
- create(base?: DeepPartial<InsertRequest_RowEntry>): InsertRequest_RowEntry {
1402
- return InsertRequest_RowEntry.fromPartial(base ?? {});
1403
- },
1404
-
1405
- fromPartial(object: DeepPartial<InsertRequest_RowEntry>): InsertRequest_RowEntry {
1406
- const message = createBaseInsertRequest_RowEntry();
1407
- message.key = object.key ?? "";
1408
- message.value = object.value ?? "";
1409
- return message;
1410
- },
1411
- };
1412
-
1413
- function createBaseCreateRequest(): CreateRequest {
1414
- return { name: "" };
1415
- }
1416
-
1417
- export const CreateRequest = {
1418
- encode(message: CreateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1419
- if (message.name !== "") {
1420
- writer.uint32(10).string(message.name);
1421
- }
1422
- return writer;
1423
- },
1424
-
1425
- decode(input: _m0.Reader | Uint8Array, length?: number): CreateRequest {
1426
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1427
- let end = length === undefined ? reader.len : reader.pos + length;
1428
- const message = createBaseCreateRequest();
1429
- while (reader.pos < end) {
1430
- const tag = reader.uint32();
1431
- switch (tag >>> 3) {
1432
- case 1:
1433
- if (tag != 10) {
1434
- break;
1435
- }
1436
-
1437
- message.name = reader.string();
1438
- continue;
1439
- }
1440
- if ((tag & 7) == 4 || tag == 0) {
1441
- break;
1442
- }
1443
- reader.skipType(tag & 7);
1444
- }
1445
- return message;
1446
- },
1447
-
1448
- create(base?: DeepPartial<CreateRequest>): CreateRequest {
1449
- return CreateRequest.fromPartial(base ?? {});
1450
- },
1451
-
1452
- fromPartial(object: DeepPartial<CreateRequest>): CreateRequest {
1453
- const message = createBaseCreateRequest();
1454
- message.name = object.name ?? "";
1455
- return message;
1456
- },
1457
- };
1458
-
1459
- function createBaseFindRequestOptions(): FindRequestOptions {
1460
- return { compressed: false, group: false, negate: false };
1461
- }
1462
-
1463
- export const FindRequestOptions = {
1464
- encode(message: FindRequestOptions, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1465
- if (message.compressed === true) {
1466
- writer.uint32(8).bool(message.compressed);
1467
- }
1468
- if (message.group === true) {
1469
- writer.uint32(16).bool(message.group);
1470
- }
1471
- if (message.negate === true) {
1472
- writer.uint32(24).bool(message.negate);
1473
- }
1474
- return writer;
1475
- },
1476
-
1477
- decode(input: _m0.Reader | Uint8Array, length?: number): FindRequestOptions {
1478
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1479
- let end = length === undefined ? reader.len : reader.pos + length;
1480
- const message = createBaseFindRequestOptions();
1481
- while (reader.pos < end) {
1482
- const tag = reader.uint32();
1483
- switch (tag >>> 3) {
1484
- case 1:
1485
- if (tag != 8) {
1486
- break;
1487
- }
1488
-
1489
- message.compressed = reader.bool();
1490
- continue;
1491
- case 2:
1492
- if (tag != 16) {
1493
- break;
1494
- }
1495
-
1496
- message.group = reader.bool();
1497
- continue;
1498
- case 3:
1499
- if (tag != 24) {
1500
- break;
1501
- }
1502
-
1503
- message.negate = reader.bool();
1504
- continue;
1505
- }
1506
- if ((tag & 7) == 4 || tag == 0) {
1507
- break;
1508
- }
1509
- reader.skipType(tag & 7);
1510
- }
1511
- return message;
1512
- },
1513
-
1514
- create(base?: DeepPartial<FindRequestOptions>): FindRequestOptions {
1515
- return FindRequestOptions.fromPartial(base ?? {});
1516
- },
1517
-
1518
- fromPartial(object: DeepPartial<FindRequestOptions>): FindRequestOptions {
1519
- const message = createBaseFindRequestOptions();
1520
- message.compressed = object.compressed ?? false;
1521
- message.group = object.group ?? false;
1522
- message.negate = object.negate ?? false;
1523
- return message;
1524
- },
1525
- };
1526
-
1527
- function createBaseField(): Field {
1528
- return { tableName: "", tableField: "" };
1529
- }
1530
-
1531
- export const Field = {
1532
- encode(message: Field, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1533
- if (message.tableName !== "") {
1534
- writer.uint32(10).string(message.tableName);
1535
- }
1536
- if (message.tableField !== "") {
1537
- writer.uint32(18).string(message.tableField);
1538
- }
1539
- return writer;
1540
- },
1541
-
1542
- decode(input: _m0.Reader | Uint8Array, length?: number): Field {
1543
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1544
- let end = length === undefined ? reader.len : reader.pos + length;
1545
- const message = createBaseField();
1546
- while (reader.pos < end) {
1547
- const tag = reader.uint32();
1548
- switch (tag >>> 3) {
1549
- case 1:
1550
- if (tag != 10) {
1551
- break;
1552
- }
1553
-
1554
- message.tableName = reader.string();
1555
- continue;
1556
- case 2:
1557
- if (tag != 18) {
1558
- break;
1559
- }
1560
-
1561
- message.tableField = reader.string();
1562
- continue;
1563
- }
1564
- if ((tag & 7) == 4 || tag == 0) {
1565
- break;
1566
- }
1567
- reader.skipType(tag & 7);
1568
- }
1569
- return message;
1570
- },
1571
-
1572
- create(base?: DeepPartial<Field>): Field {
1573
- return Field.fromPartial(base ?? {});
1574
- },
1575
-
1576
- fromPartial(object: DeepPartial<Field>): Field {
1577
- const message = createBaseField();
1578
- message.tableName = object.tableName ?? "";
1579
- message.tableField = object.tableField ?? "";
1580
- return message;
1581
- },
1582
- };
1583
-
1584
- function createBaseFieldPair(): FieldPair {
1585
- return { field1: undefined, field2: undefined };
1586
- }
1587
-
1588
- export const FieldPair = {
1589
- encode(message: FieldPair, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1590
- if (message.field1 !== undefined) {
1591
- Field.encode(message.field1, writer.uint32(10).fork()).ldelim();
1592
- }
1593
- if (message.field2 !== undefined) {
1594
- Field.encode(message.field2, writer.uint32(18).fork()).ldelim();
1595
- }
1596
- return writer;
1597
- },
1598
-
1599
- decode(input: _m0.Reader | Uint8Array, length?: number): FieldPair {
1600
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1601
- let end = length === undefined ? reader.len : reader.pos + length;
1602
- const message = createBaseFieldPair();
1603
- while (reader.pos < end) {
1604
- const tag = reader.uint32();
1605
- switch (tag >>> 3) {
1606
- case 1:
1607
- if (tag != 10) {
1608
- break;
1609
- }
1610
-
1611
- message.field1 = Field.decode(reader, reader.uint32());
1612
- continue;
1613
- case 2:
1614
- if (tag != 18) {
1615
- break;
1616
- }
1617
-
1618
- message.field2 = Field.decode(reader, reader.uint32());
1619
- continue;
1620
- }
1621
- if ((tag & 7) == 4 || tag == 0) {
1622
- break;
1623
- }
1624
- reader.skipType(tag & 7);
1625
- }
1626
- return message;
1627
- },
1628
-
1629
- create(base?: DeepPartial<FieldPair>): FieldPair {
1630
- return FieldPair.fromPartial(base ?? {});
1631
- },
1632
-
1633
- fromPartial(object: DeepPartial<FieldPair>): FieldPair {
1634
- const message = createBaseFieldPair();
1635
- message.field1 =
1636
- object.field1 !== undefined && object.field1 !== null ? Field.fromPartial(object.field1) : undefined;
1637
- message.field2 =
1638
- object.field2 !== undefined && object.field2 !== null ? Field.fromPartial(object.field2) : undefined;
1639
- return message;
1640
- },
1641
- };
1642
-
1643
- function createBaseProjectedField(): ProjectedField {
1644
- return { field: undefined, rename: undefined };
1645
- }
1646
-
1647
- export const ProjectedField = {
1648
- encode(message: ProjectedField, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1649
- if (message.field !== undefined) {
1650
- Field.encode(message.field, writer.uint32(10).fork()).ldelim();
1651
- }
1652
- if (message.rename !== undefined) {
1653
- writer.uint32(18).string(message.rename);
1654
- }
1655
- return writer;
1656
- },
1657
-
1658
- decode(input: _m0.Reader | Uint8Array, length?: number): ProjectedField {
1659
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1660
- let end = length === undefined ? reader.len : reader.pos + length;
1661
- const message = createBaseProjectedField();
1662
- while (reader.pos < end) {
1663
- const tag = reader.uint32();
1664
- switch (tag >>> 3) {
1665
- case 1:
1666
- if (tag != 10) {
1667
- break;
1668
- }
1669
-
1670
- message.field = Field.decode(reader, reader.uint32());
1671
- continue;
1672
- case 2:
1673
- if (tag != 18) {
1674
- break;
1675
- }
1676
-
1677
- message.rename = reader.string();
1678
- continue;
1679
- }
1680
- if ((tag & 7) == 4 || tag == 0) {
1681
- break;
1682
- }
1683
- reader.skipType(tag & 7);
1684
- }
1685
- return message;
1686
- },
1687
-
1688
- create(base?: DeepPartial<ProjectedField>): ProjectedField {
1689
- return ProjectedField.fromPartial(base ?? {});
1690
- },
1691
-
1692
- fromPartial(object: DeepPartial<ProjectedField>): ProjectedField {
1693
- const message = createBaseProjectedField();
1694
- message.field = object.field !== undefined && object.field !== null ? Field.fromPartial(object.field) : undefined;
1695
- message.rename = object.rename ?? undefined;
1696
- return message;
1697
- },
1698
- };
1699
-
1700
- function createBaseFilter(): Filter {
1701
- return { field: undefined, operator: "", value: "", function: "" };
1702
- }
1703
-
1704
- export const Filter = {
1705
- encode(message: Filter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
1706
- if (message.field !== undefined) {
1707
- Field.encode(message.field, writer.uint32(10).fork()).ldelim();
1708
- }
1709
- if (message.operator !== "") {
1710
- writer.uint32(18).string(message.operator);
1711
- }
1712
- if (message.value !== "") {
1713
- writer.uint32(26).string(message.value);
1714
- }
1715
- if (message.function !== "") {
1716
- writer.uint32(34).string(message.function);
1717
- }
1718
- return writer;
1719
- },
1720
-
1721
- decode(input: _m0.Reader | Uint8Array, length?: number): Filter {
1722
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1723
- let end = length === undefined ? reader.len : reader.pos + length;
1724
- const message = createBaseFilter();
1725
- while (reader.pos < end) {
1726
- const tag = reader.uint32();
1727
- switch (tag >>> 3) {
1728
- case 1:
1729
- if (tag != 10) {
1730
- break;
1731
- }
1732
-
1733
- message.field = Field.decode(reader, reader.uint32());
1734
- continue;
1735
- case 2:
1736
- if (tag != 18) {
1737
- break;
1738
- }
1739
-
1740
- message.operator = reader.string();
1741
- continue;
1742
- case 3:
1743
- if (tag != 26) {
1744
- break;
1745
- }
1746
-
1747
- message.value = reader.string();
1748
- continue;
1749
- case 4:
1750
- if (tag != 34) {
1751
- break;
1752
- }
1753
-
1754
- message.function = reader.string();
1755
- continue;
1756
- }
1757
- if ((tag & 7) == 4 || tag == 0) {
1758
- break;
1759
- }
1760
- reader.skipType(tag & 7);
1761
- }
1762
- return message;
1763
- },
1764
-
1765
- create(base?: DeepPartial<Filter>): Filter {
1766
- return Filter.fromPartial(base ?? {});
1767
- },
1768
-
1769
- fromPartial(object: DeepPartial<Filter>): Filter {
1770
- const message = createBaseFilter();
1771
- message.field = object.field !== undefined && object.field !== null ? Field.fromPartial(object.field) : undefined;
1772
- message.operator = object.operator ?? "";
1773
- message.value = object.value ?? "";
1774
- message.function = object.function ?? "";
1775
- return message;
1776
- },
1777
- };
1778
-
1779
- export type QueryLayerDefinition = typeof QueryLayerDefinition;
1780
- export const QueryLayerDefinition = {
1781
- name: "QueryLayer",
1782
- fullName: "mode.QueryLayer",
1783
- methods: {
1784
- /** Get state endpoint. */
1785
- getState: {
1786
- name: "GetState",
1787
- requestType: StateRequest,
1788
- requestStream: false,
1789
- responseType: QueryLayerStateResponse,
1790
- responseStream: false,
1791
- options: {},
1792
- },
1793
- /** Stream state endpoint. */
1794
- streamState: {
1795
- name: "StreamState",
1796
- requestType: StateRequest,
1797
- requestStream: false,
1798
- responseType: QueryLayerStateStreamResponse,
1799
- responseStream: true,
1800
- options: {},
1801
- },
1802
- /** Get state from single table endpoint. */
1803
- single__GetState: {
1804
- name: "Single__GetState",
1805
- requestType: SingleStateRequest,
1806
- requestStream: false,
1807
- responseType: QueryLayerStateResponse,
1808
- responseStream: false,
1809
- options: {},
1810
- },
1811
- /** Stream state from single table endpoint. */
1812
- single__StreamState: {
1813
- name: "Single__StreamState",
1814
- requestType: SingleStateRequest,
1815
- requestStream: false,
1816
- responseType: QueryLayerStateStreamResponse,
1817
- responseStream: true,
1818
- options: {},
1819
- },
1820
- },
1821
- } as const;
1822
-
1823
- export interface QueryLayerServiceImplementation<CallContextExt = {}> {
1824
- /** Get state endpoint. */
1825
- getState(request: StateRequest, context: CallContext & CallContextExt): Promise<DeepPartial<QueryLayerStateResponse>>;
1826
- /** Stream state endpoint. */
1827
- streamState(
1828
- request: StateRequest,
1829
- context: CallContext & CallContextExt
1830
- ): ServerStreamingMethodResult<DeepPartial<QueryLayerStateStreamResponse>>;
1831
- /** Get state from single table endpoint. */
1832
- single__GetState(
1833
- request: SingleStateRequest,
1834
- context: CallContext & CallContextExt
1835
- ): Promise<DeepPartial<QueryLayerStateResponse>>;
1836
- /** Stream state from single table endpoint. */
1837
- single__StreamState(
1838
- request: SingleStateRequest,
1839
- context: CallContext & CallContextExt
1840
- ): ServerStreamingMethodResult<DeepPartial<QueryLayerStateStreamResponse>>;
1841
- }
1842
-
1843
- export interface QueryLayerClient<CallOptionsExt = {}> {
1844
- /** Get state endpoint. */
1845
- getState(
1846
- request: DeepPartial<StateRequest>,
1847
- options?: CallOptions & CallOptionsExt
1848
- ): Promise<QueryLayerStateResponse>;
1849
- /** Stream state endpoint. */
1850
- streamState(
1851
- request: DeepPartial<StateRequest>,
1852
- options?: CallOptions & CallOptionsExt
1853
- ): AsyncIterable<QueryLayerStateStreamResponse>;
1854
- /** Get state from single table endpoint. */
1855
- single__GetState(
1856
- request: DeepPartial<SingleStateRequest>,
1857
- options?: CallOptions & CallOptionsExt
1858
- ): Promise<QueryLayerStateResponse>;
1859
- /** Stream state from single table endpoint. */
1860
- single__StreamState(
1861
- request: DeepPartial<SingleStateRequest>,
1862
- options?: CallOptions & CallOptionsExt
1863
- ): AsyncIterable<QueryLayerStateStreamResponse>;
1864
- }
1865
-
1866
- type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
1867
-
1868
- export type DeepPartial<T> = T extends Builtin
1869
- ? T
1870
- : T extends Array<infer U>
1871
- ? Array<DeepPartial<U>>
1872
- : T extends ReadonlyArray<infer U>
1873
- ? ReadonlyArray<DeepPartial<U>>
1874
- : T extends {}
1875
- ? { [K in keyof T]?: DeepPartial<T[K]> }
1876
- : Partial<T>;
1877
-
1878
- export type ServerStreamingMethodResult<Response> = { [Symbol.asyncIterator](): AsyncIterator<Response, void> };