datai-sdk 1.0.0 → 1.0.1

package/API/v1/proto/ethereum/ValuesPb.ts

@@ -3,51 +3,51 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
-import { ValuePb } from './ValuePb'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
+import { ValuePb } from "./ValuePb";
 
 export class ValuesPb {
   static encode(message: ValuesPb, writer: Writer): void {
-    const values = message.values
+    const values = message.values;
     for (let i: i32 = 0; i < values.length; ++i) {
-      writer.uint32(10)
-      writer.fork()
-      ValuePb.encode(values[i], writer)
-      writer.ldelim()
+      writer.uint32(10);
+      writer.fork();
+      ValuePb.encode(values[i], writer);
+      writer.ldelim();
     }
   }
 
   static decode(reader: Reader, length: i32): ValuesPb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new ValuesPb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new ValuesPb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.values.push(ValuePb.decode(reader, reader.uint32()))
-          break
+          message.values.push(ValuePb.decode(reader, reader.uint32()));
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  values: Array<ValuePb>
+  values: Array<ValuePb>;
 
   constructor(values: Array<ValuePb> = []) {
-    this.values = values
+    this.values = values;
   }
 }
 
 export function encodeValuesPb(message: ValuesPb): Uint8Array {
-  return Protobuf.encode(message, ValuesPb.encode)
+  return Protobuf.encode(message, ValuesPb.encode);
 }
 
 export function decodeValuesPb(buffer: Uint8Array): ValuesPb {
-  return Protobuf.decode<ValuesPb>(buffer, ValuesPb.decode)
+  return Protobuf.decode<ValuesPb>(buffer, ValuesPb.decode);
 }

package/API/v1/proto/google/protobuf/Any.ts

@@ -3,54 +3,54 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
 
 export class Any {
   static encode(message: Any, writer: Writer): void {
-    writer.uint32(10)
-    writer.string(message.typeUrl)
+    writer.uint32(10);
+    writer.string(message.typeUrl);
 
-    writer.uint32(18)
-    writer.bytes(message.value)
+    writer.uint32(18);
+    writer.bytes(message.value);
   }
 
   static decode(reader: Reader, length: i32): Any {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new Any()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new Any();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.typeUrl = reader.string()
-          break
+          message.typeUrl = reader.string();
+          break;
 
         case 2:
-          message.value = reader.bytes()
-          break
+          message.value = reader.bytes();
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  typeUrl: string
-  value: Uint8Array
+  typeUrl: string;
+  value: Uint8Array;
 
-  constructor(typeUrl: string = '', value: Uint8Array = new Uint8Array(0)) {
-    this.typeUrl = typeUrl
-    this.value = value
+  constructor(typeUrl: string = "", value: Uint8Array = new Uint8Array(0)) {
+    this.typeUrl = typeUrl;
+    this.value = value;
   }
 }
 
 export function encodeAny(message: Any): Uint8Array {
-  return Protobuf.encode(message, Any.encode)
+  return Protobuf.encode(message, Any.encode);
 }
 
 export function decodeAny(buffer: Uint8Array): Any {
-  return Protobuf.decode<Any>(buffer, Any.decode)
+  return Protobuf.decode<Any>(buffer, Any.decode);
 }

package/API/v1/proto/google/protobuf/Timestamp.ts

@@ -3,54 +3,54 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
 
 export class Timestamp {
   static encode(message: Timestamp, writer: Writer): void {
-    writer.uint32(8)
-    writer.int64(message.seconds)
+    writer.uint32(8);
+    writer.int64(message.seconds);
 
-    writer.uint32(16)
-    writer.int32(message.nanos)
+    writer.uint32(16);
+    writer.int32(message.nanos);
   }
 
   static decode(reader: Reader, length: i32): Timestamp {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new Timestamp()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new Timestamp();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.seconds = reader.int64()
-          break
+          message.seconds = reader.int64();
+          break;
 
         case 2:
-          message.nanos = reader.int32()
-          break
+          message.nanos = reader.int32();
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  seconds: i64
-  nanos: i32
+  seconds: i64;
+  nanos: i32;
 
   constructor(seconds: i64 = 0, nanos: i32 = 0) {
-    this.seconds = seconds
-    this.nanos = nanos
+    this.seconds = seconds;
+    this.nanos = nanos;
   }
 }
 
 export function encodeTimestamp(message: Timestamp): Uint8Array {
-  return Protobuf.encode(message, Timestamp.encode)
+  return Protobuf.encode(message, Timestamp.encode);
 }
 
 export function decodeTimestamp(buffer: Uint8Array): Timestamp {
-  return Protobuf.decode<Timestamp>(buffer, Timestamp.decode)
+  return Protobuf.decode<Timestamp>(buffer, Timestamp.decode);
 }

package/API/v1/proto/store/EntitiesPb.ts

@@ -3,51 +3,51 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
-import { EntityPb } from './EntityPb'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
+import { EntityPb } from "./EntityPb";
 
 export class EntitiesPb {
   static encode(message: EntitiesPb, writer: Writer): void {
-    const items = message.items
+    const items = message.items;
     for (let i: i32 = 0; i < items.length; ++i) {
-      writer.uint32(10)
-      writer.fork()
-      EntityPb.encode(items[i], writer)
-      writer.ldelim()
+      writer.uint32(10);
+      writer.fork();
+      EntityPb.encode(items[i], writer);
+      writer.ldelim();
     }
   }
 
   static decode(reader: Reader, length: i32): EntitiesPb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new EntitiesPb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new EntitiesPb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.items.push(EntityPb.decode(reader, reader.uint32()))
-          break
+          message.items.push(EntityPb.decode(reader, reader.uint32()));
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  items: Array<EntityPb>
+  items: Array<EntityPb>;
 
   constructor(items: Array<EntityPb> = []) {
-    this.items = items
+    this.items = items;
   }
 }
 
 export function encodeEntitiesPb(message: EntitiesPb): Uint8Array {
-  return Protobuf.encode(message, EntitiesPb.encode)
+  return Protobuf.encode(message, EntitiesPb.encode);
 }
 
 export function decodeEntitiesPb(buffer: Uint8Array): EntitiesPb {
-  return Protobuf.decode<EntitiesPb>(buffer, EntitiesPb.decode)
+  return Protobuf.decode<EntitiesPb>(buffer, EntitiesPb.decode);
 }

package/API/v1/proto/store/EntityPb.ts

@@ -3,97 +3,97 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
-import { ValuePb } from './ValuePb'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
+import { ValuePb } from "./ValuePb";
 
 export class EntityPb {
   static encode(message: EntityPb, writer: Writer): void {
-    const entries = message.entries
+    const entries = message.entries;
     if (entries !== null) {
-      const entriesKeys = entries.keys()
+      const entriesKeys = entries.keys();
       for (let i: i32 = 0; i < entriesKeys.length; ++i) {
-        const entriesKey = entriesKeys[i]
-        writer.uint32(10)
-        writer.fork()
-        writer.uint32(10)
-        writer.string(entriesKey)
-        writer.uint32(18)
-        writer.fork()
-        ValuePb.encode(entries.get(entriesKey), writer)
-        writer.ldelim()
-        writer.ldelim()
+        const entriesKey = entriesKeys[i];
+        writer.uint32(10);
+        writer.fork();
+        writer.uint32(10);
+        writer.string(entriesKey);
+        writer.uint32(18);
+        writer.fork();
+        ValuePb.encode(entries.get(entriesKey), writer);
+        writer.ldelim();
+        writer.ldelim();
       }
     }
   }
 
   static decode(reader: Reader, length: i32): EntityPb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new EntityPb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new EntityPb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          let entriesKey: string = ''
-          let entriesValue: ValuePb | null = null
-          let entriesHasKey: bool = false
-          let entriesHasValue: bool = false
+          let entriesKey: string = "";
+          let entriesValue: ValuePb | null = null;
+          let entriesHasKey: bool = false;
+          let entriesHasValue: bool = false;
           for (
             const end: usize = reader.ptr + reader.uint32();
             reader.ptr < end;
 
           ) {
-            const tag = reader.uint32()
+            const tag = reader.uint32();
             switch (tag >>> 3) {
               case 1:
-                entriesKey = reader.string()
-                entriesHasKey = true
-                break
+                entriesKey = reader.string();
+                entriesHasKey = true;
+                break;
 
               case 2:
-                entriesValue = ValuePb.decode(reader, reader.uint32())
-                entriesHasValue = true
-                break
+                entriesValue = ValuePb.decode(reader, reader.uint32());
+                entriesHasValue = true;
+                break;
 
               default:
-                reader.skipType(tag & 7)
-                break
+                reader.skipType(tag & 7);
+                break;
             }
             if (message.entries === null) {
-              message.entries = new Map<string, ValuePb>()
+              message.entries = new Map<string, ValuePb>();
             }
-            const entries = message.entries
+            const entries = message.entries;
             if (
               entries !== null &&
               entriesHasKey &&
               entriesHasValue &&
               entriesValue !== null
             ) {
-              entries.set(entriesKey, entriesValue)
+              entries.set(entriesKey, entriesValue);
             }
           }
-          break
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  entries: Map<string, ValuePb>
+  entries: Map<string, ValuePb>;
 
   constructor(entries: Map<string, ValuePb> = new Map()) {
-    this.entries = entries
+    this.entries = entries;
   }
 }
 
 export function encodeEntityPb(message: EntityPb): Uint8Array {
-  return Protobuf.encode(message, EntityPb.encode)
+  return Protobuf.encode(message, EntityPb.encode);
 }
 
 export function decodeEntityPb(buffer: Uint8Array): EntityPb {
-  return Protobuf.decode<EntityPb>(buffer, EntityPb.decode)
+  return Protobuf.decode<EntityPb>(buffer, EntityPb.decode);
 }

package/API/v1/proto/store/EntityWithMetaPb.ts

@@ -3,73 +3,73 @@
 //   protoc-gen-as v1.3.0
 //   protoc        v3.21.12
 
-import { Writer, Reader, Protobuf } from 'as-proto/assembly'
-import { EntityPb } from './EntityPb'
+import { Writer, Reader, Protobuf } from "as-proto/assembly";
+import { EntityPb } from "./EntityPb";
 
 export class EntityWithMetaPb {
   static encode(message: EntityWithMetaPb, writer: Writer): void {
-    const entity = message.entity
+    const entity = message.entity;
     if (entity !== null) {
-      writer.uint32(10)
-      writer.fork()
-      EntityPb.encode(entity, writer)
-      writer.ldelim()
+      writer.uint32(10);
+      writer.fork();
+      EntityPb.encode(entity, writer);
+      writer.ldelim();
     }
 
-    writer.uint32(18)
-    writer.string(message.idField)
+    writer.uint32(18);
+    writer.string(message.idField);
 
-    writer.uint32(24)
-    writer.bool(message.isImmutable)
+    writer.uint32(24);
+    writer.bool(message.isImmutable);
   }
 
   static decode(reader: Reader, length: i32): EntityWithMetaPb {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length
-    const message = new EntityWithMetaPb()
+    const end: usize = length < 0 ? reader.end : reader.ptr + length;
+    const message = new EntityWithMetaPb();
 
     while (reader.ptr < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.entity = EntityPb.decode(reader, reader.uint32())
-          break
+          message.entity = EntityPb.decode(reader, reader.uint32());
+          break;
 
         case 2:
-          message.idField = reader.string()
-          break
+          message.idField = reader.string();
+          break;
 
         case 3:
-          message.isImmutable = reader.bool()
-          break
+          message.isImmutable = reader.bool();
+          break;
 
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
 
-    return message
+    return message;
   }
 
-  entity: EntityPb | null
-  idField: string
-  isImmutable: bool
+  entity: EntityPb | null;
+  idField: string;
+  isImmutable: bool;
 
   constructor(
     entity: EntityPb | null = null,
-    idField: string = '',
+    idField: string = "",
     isImmutable: bool = false
   ) {
-    this.entity = entity
-    this.idField = idField
-    this.isImmutable = isImmutable
+    this.entity = entity;
+    this.idField = idField;
+    this.isImmutable = isImmutable;
   }
 }
 
 export function encodeEntityWithMetaPb(message: EntityWithMetaPb): Uint8Array {
-  return Protobuf.encode(message, EntityWithMetaPb.encode)
+  return Protobuf.encode(message, EntityWithMetaPb.encode);
 }
 
 export function decodeEntityWithMetaPb(buffer: Uint8Array): EntityWithMetaPb {
-  return Protobuf.decode<EntityWithMetaPb>(buffer, EntityWithMetaPb.decode)
+  return Protobuf.decode<EntityWithMetaPb>(buffer, EntityWithMetaPb.decode);
 }

package/API/v1/proto/store/ValueKindPb.ts

@@ -13,5 +13,5 @@ export enum ValueKindPb {
   BYTES = 6,
   BIGINT = 7,
   INT8 = 8,
-  TIMESTAMP = 9
+  TIMESTAMP = 9,
 }