@restatedev/restate-sdk 0.7.3-worker → 0.8.1

package/src/generated/proto/javascript.ts

@@ -0,0 +1,488 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { FileDescriptorProto as FileDescriptorProto1 } from "ts-proto-descriptors";
+import { Failure, protoMetadata as protoMetadata1 } from "./protocol";
+
+export const protobufPackage = "dev.restate.sdk.javascript";
+
+export interface FailureWithTerminal {
+  failure: Failure | undefined;
+  terminal: boolean;
+}
+
+/**
+ * Type: 0xFC00 + 1
+ * Flag: RequiresRuntimeAck
+ */
+export interface SideEffectEntryMessage {
+  value?: Buffer | undefined;
+  failure?: FailureWithTerminal | undefined;
+}
+
+/** Type: 0xFC00 + 2 */
+export interface CombinatorEntryMessage {
+  combinatorId: number;
+  journalEntriesOrder: number[];
+}
+
+function createBaseFailureWithTerminal(): FailureWithTerminal {
+  return { failure: undefined, terminal: false };
+}
+
+export const FailureWithTerminal = {
+  encode(message: FailureWithTerminal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.failure !== undefined) {
+      Failure.encode(message.failure, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.terminal === true) {
+      writer.uint32(16).bool(message.terminal);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): FailureWithTerminal {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFailureWithTerminal();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.failure = Failure.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.terminal = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FailureWithTerminal {
+    return {
+      failure: isSet(object.failure) ? Failure.fromJSON(object.failure) : undefined,
+      terminal: isSet(object.terminal) ? globalThis.Boolean(object.terminal) : false,
+    };
+  },
+
+  toJSON(message: FailureWithTerminal): unknown {
+    const obj: any = {};
+    if (message.failure !== undefined) {
+      obj.failure = Failure.toJSON(message.failure);
+    }
+    if (message.terminal === true) {
+      obj.terminal = message.terminal;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<FailureWithTerminal>): FailureWithTerminal {
+    return FailureWithTerminal.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<FailureWithTerminal>): FailureWithTerminal {
+    const message = createBaseFailureWithTerminal();
+    message.failure = (object.failure !== undefined && object.failure !== null)
+      ? Failure.fromPartial(object.failure)
+      : undefined;
+    message.terminal = object.terminal ?? false;
+    return message;
+  },
+};
+
+function createBaseSideEffectEntryMessage(): SideEffectEntryMessage {
+  return { value: undefined, failure: undefined };
+}
+
+export const SideEffectEntryMessage = {
+  encode(message: SideEffectEntryMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.value !== undefined) {
+      writer.uint32(114).bytes(message.value);
+    }
+    if (message.failure !== undefined) {
+      FailureWithTerminal.encode(message.failure, writer.uint32(122).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SideEffectEntryMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSideEffectEntryMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 14:
+          if (tag !== 114) {
+            break;
+          }
+
+          message.value = reader.bytes() as Buffer;
+          continue;
+        case 15:
+          if (tag !== 122) {
+            break;
+          }
+
+          message.failure = FailureWithTerminal.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SideEffectEntryMessage {
+    return {
+      value: isSet(object.value) ? Buffer.from(bytesFromBase64(object.value)) : undefined,
+      failure: isSet(object.failure) ? FailureWithTerminal.fromJSON(object.failure) : undefined,
+    };
+  },
+
+  toJSON(message: SideEffectEntryMessage): unknown {
+    const obj: any = {};
+    if (message.value !== undefined) {
+      obj.value = base64FromBytes(message.value);
+    }
+    if (message.failure !== undefined) {
+      obj.failure = FailureWithTerminal.toJSON(message.failure);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SideEffectEntryMessage>): SideEffectEntryMessage {
+    return SideEffectEntryMessage.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SideEffectEntryMessage>): SideEffectEntryMessage {
+    const message = createBaseSideEffectEntryMessage();
+    message.value = object.value ?? undefined;
+    message.failure = (object.failure !== undefined && object.failure !== null)
+      ? FailureWithTerminal.fromPartial(object.failure)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseCombinatorEntryMessage(): CombinatorEntryMessage {
+  return { combinatorId: 0, journalEntriesOrder: [] };
+}
+
+export const CombinatorEntryMessage = {
+  encode(message: CombinatorEntryMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.combinatorId !== 0) {
+      writer.uint32(8).int32(message.combinatorId);
+    }
+    writer.uint32(18).fork();
+    for (const v of message.journalEntriesOrder) {
+      writer.int32(v);
+    }
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CombinatorEntryMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCombinatorEntryMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.combinatorId = reader.int32();
+          continue;
+        case 2:
+          if (tag === 16) {
+            message.journalEntriesOrder.push(reader.int32());
+
+            continue;
+          }
+
+          if (tag === 18) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.journalEntriesOrder.push(reader.int32());
+            }
+
+            continue;
+          }
+
+          break;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CombinatorEntryMessage {
+    return {
+      combinatorId: isSet(object.combinatorId) ? globalThis.Number(object.combinatorId) : 0,
+      journalEntriesOrder: globalThis.Array.isArray(object?.journalEntriesOrder)
+        ? object.journalEntriesOrder.map((e: any) => globalThis.Number(e))
+        : [],
+    };
+  },
+
+  toJSON(message: CombinatorEntryMessage): unknown {
+    const obj: any = {};
+    if (message.combinatorId !== 0) {
+      obj.combinatorId = Math.round(message.combinatorId);
+    }
+    if (message.journalEntriesOrder?.length) {
+      obj.journalEntriesOrder = message.journalEntriesOrder.map((e) => Math.round(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<CombinatorEntryMessage>): CombinatorEntryMessage {
+    return CombinatorEntryMessage.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<CombinatorEntryMessage>): CombinatorEntryMessage {
+    const message = createBaseCombinatorEntryMessage();
+    message.combinatorId = object.combinatorId ?? 0;
+    message.journalEntriesOrder = object.journalEntriesOrder?.map((e) => e) || [];
+    return message;
+  },
+};
+
+type ProtoMetaMessageOptions = {
+  options?: { [key: string]: any };
+  fields?: { [key: string]: { [key: string]: any } };
+  oneof?: { [key: string]: { [key: string]: any } };
+  nested?: { [key: string]: ProtoMetaMessageOptions };
+};
+
+export interface ProtoMetadata {
+  fileDescriptor: FileDescriptorProto1;
+  references: { [key: string]: any };
+  dependencies?: ProtoMetadata[];
+  options?: {
+    options?: { [key: string]: any };
+    services?: {
+      [key: string]: { options?: { [key: string]: any }; methods?: { [key: string]: { [key: string]: any } } };
+    };
+    messages?: { [key: string]: ProtoMetaMessageOptions };
+    enums?: { [key: string]: { options?: { [key: string]: any }; values?: { [key: string]: { [key: string]: any } } } };
+  };
+}
+
+export const protoMetadata: ProtoMetadata = {
+  fileDescriptor: FileDescriptorProto1.fromPartial({
+    "name": "proto/javascript.proto",
+    "package": "dev.restate.sdk.javascript",
+    "dependency": ["proto/protocol.proto"],
+    "publicDependency": [],
+    "weakDependency": [],
+    "messageType": [{
+      "name": "FailureWithTerminal",
+      "field": [{
+        "name": "failure",
+        "number": 1,
+        "label": 1,
+        "type": 11,
+        "typeName": ".dev.restate.service.protocol.Failure",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "failure",
+        "options": undefined,
+        "proto3Optional": false,
+      }, {
+        "name": "terminal",
+        "number": 2,
+        "label": 1,
+        "type": 8,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "terminal",
+        "options": undefined,
+        "proto3Optional": false,
+      }],
+      "extension": [],
+      "nestedType": [],
+      "enumType": [],
+      "extensionRange": [],
+      "oneofDecl": [],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }, {
+      "name": "SideEffectEntryMessage",
+      "field": [{
+        "name": "value",
+        "number": 14,
+        "label": 1,
+        "type": 12,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "value",
+        "options": undefined,
+        "proto3Optional": false,
+      }, {
+        "name": "failure",
+        "number": 15,
+        "label": 1,
+        "type": 11,
+        "typeName": ".dev.restate.sdk.javascript.FailureWithTerminal",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "failure",
+        "options": undefined,
+        "proto3Optional": false,
+      }],
+      "extension": [],
+      "nestedType": [],
+      "enumType": [],
+      "extensionRange": [],
+      "oneofDecl": [{ "name": "result", "options": undefined }],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }, {
+      "name": "CombinatorEntryMessage",
+      "field": [{
+        "name": "combinator_id",
+        "number": 1,
+        "label": 1,
+        "type": 5,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "combinatorId",
+        "options": undefined,
+        "proto3Optional": false,
+      }, {
+        "name": "journal_entries_order",
+        "number": 2,
+        "label": 3,
+        "type": 5,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "journalEntriesOrder",
+        "options": undefined,
+        "proto3Optional": false,
+      }],
+      "extension": [],
+      "nestedType": [],
+      "enumType": [],
+      "extensionRange": [],
+      "oneofDecl": [],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }],
+    "enumType": [],
+    "service": [],
+    "extension": [],
+    "options": {
+      "javaPackage": "com.dev.restate.sdk.javascript",
+      "javaOuterClassname": "JavascriptProto",
+      "javaMultipleFiles": true,
+      "javaGenerateEqualsAndHash": false,
+      "javaStringCheckUtf8": false,
+      "optimizeFor": 1,
+      "goPackage": "",
+      "ccGenericServices": false,
+      "javaGenericServices": false,
+      "pyGenericServices": false,
+      "phpGenericServices": false,
+      "deprecated": false,
+      "ccEnableArenas": false,
+      "objcClassPrefix": "DRSJ",
+      "csharpNamespace": "Dev.Restate.Sdk.Javascript",
+      "swiftPrefix": "",
+      "phpClassPrefix": "",
+      "phpNamespace": "Dev\\Restate\\Sdk\\Javascript",
+      "phpMetadataNamespace": "Dev\\Restate\\Sdk\\Javascript\\GPBMetadata",
+      "rubyPackage": "Dev::Restate::Sdk::Javascript",
+      "uninterpretedOption": [],
+    },
+    "sourceCodeInfo": {
+      "location": [{
+        "path": [4, 1],
+        "span": [24, 0, 29, 1],
+        "leadingComments": " Type: 0xFC00 + 1\n Flag: RequiresRuntimeAck\n",
+        "trailingComments": "",
+        "leadingDetachedComments": [],
+      }, {
+        "path": [4, 2],
+        "span": [32, 0, 36, 1],
+        "leadingComments": " Type: 0xFC00 + 2\n",
+        "trailingComments": "",
+        "leadingDetachedComments": [],
+      }],
+    },
+    "syntax": "proto3",
+  }),
+  references: {
+    ".dev.restate.sdk.javascript.FailureWithTerminal": FailureWithTerminal,
+    ".dev.restate.sdk.javascript.SideEffectEntryMessage": SideEffectEntryMessage,
+    ".dev.restate.sdk.javascript.CombinatorEntryMessage": CombinatorEntryMessage,
+  },
+  dependencies: [protoMetadata1],
+};
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}