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