@cratis/chronicle.contracts 19.128.1 → 19.130.0

package/generated/projections.ts

@@ -338,6 +338,85 @@ export interface GetAllDefinitionsRequest {
   EventStore: string;
 }
 
+export interface GraphEdgeFromDefinition {
+  SourceKey: string;
+  TargetKey: string;
+  Identity: string;
+  Properties: { [key: string]: string };
+}
+
+export interface GraphEdgeFromDefinition_PropertiesEntry {
+  key: string;
+  value: string;
+}
+
+export interface GraphEdgeProjectionDefinition {
+  From: { [key: string]: GraphEdgeFromDefinition };
+  RemovedWith: { [key: string]: GraphEdgeRemovedWithDefinition };
+}
+
+export interface GraphEdgeProjectionDefinition_FromEntry {
+  key: string;
+  value: GraphEdgeFromDefinition | undefined;
+}
+
+export interface GraphEdgeProjectionDefinition_RemovedWithEntry {
+  key: string;
+  value: GraphEdgeRemovedWithDefinition | undefined;
+}
+
+export interface GraphEdgeRemovedWithDefinition {
+  SourceKey: string;
+  TargetKey: string;
+  Identity: string;
+}
+
+export interface GraphNodeFromDefinition {
+  Key: string;
+  Properties: { [key: string]: string };
+  UpdateOnly: boolean;
+}
+
+export interface GraphNodeFromDefinition_PropertiesEntry {
+  key: string;
+  value: string;
+}
+
+export interface GraphNodeProjectionDefinition {
+  From: { [key: string]: GraphNodeFromDefinition };
+  RemovedWith: { [key: string]: GraphNodeRemovedWithDefinition };
+}
+
+export interface GraphNodeProjectionDefinition_FromEntry {
+  key: string;
+  value: GraphNodeFromDefinition | undefined;
+}
+
+export interface GraphNodeProjectionDefinition_RemovedWithEntry {
+  key: string;
+  value: GraphNodeRemovedWithDefinition | undefined;
+}
+
+export interface GraphNodeRemovedWithDefinition {
+  Key: string;
+  Detach: boolean;
+}
+
+export interface GraphProjectionDefinition {
+  Nodes: { [key: string]: GraphNodeProjectionDefinition };
+  Edges: { [key: string]: GraphEdgeProjectionDefinition };
+}
+
+export interface GraphProjectionDefinition_NodesEntry {
+  key: string;
+  value: GraphNodeProjectionDefinition | undefined;
+}
+
+export interface GraphProjectionDefinition_EdgesEntry {
+  key: string;
+  value: GraphEdgeProjectionDefinition | undefined;
+}
+
 export interface IEnumerableProjectionDefinition {
   items: ProjectionDefinition[];
 }
@@ -434,6 +513,7 @@ export interface ProjectionDefinition {
   SubscribesToAllEvents: boolean;
   NoAutoMapProperties: string[];
   GenerationDelivery: EventGenerationDelivery;
+  Graph: GraphProjectionDefinition | undefined;
 }
 
 export interface ProjectionDefinition_ChildrenEntry {
@@ -1647,18 +1727,1686 @@ function createBaseFromEventPropertyDefinition(): FromEventPropertyDefinition {
   return { Event: undefined, PropertyExpression: "" };
 }
 
-export const FromEventPropertyDefinition: MessageFns<FromEventPropertyDefinition> = {
-  encode(message: FromEventPropertyDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.Event !== undefined) {
-      EventType.encode(message.Event, writer.uint32(10).fork()).join();
+export const FromEventPropertyDefinition: MessageFns<FromEventPropertyDefinition> = {
+  encode(message: FromEventPropertyDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Event !== undefined) {
+      EventType.encode(message.Event, writer.uint32(10).fork()).join();
+    }
+    if (message.PropertyExpression !== "") {
+      writer.uint32(18).string(message.PropertyExpression);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): FromEventPropertyDefinition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseFromEventPropertyDefinition();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.Event = EventType.decode(reader, reader.uint32());
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.PropertyExpression = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): FromEventPropertyDefinition {
+    return {
+      Event: isSet(object.Event) ? EventType.fromJSON(object.Event) : undefined,
+      PropertyExpression: isSet(object.PropertyExpression) ? globalThis.String(object.PropertyExpression) : "",
+    };
+  },
+
+  toJSON(message: FromEventPropertyDefinition): unknown {
+    const obj: any = {};
+    if (message.Event !== undefined) {
+      obj.Event = EventType.toJSON(message.Event);
+    }
+    if (message.PropertyExpression !== "") {
+      obj.PropertyExpression = message.PropertyExpression;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<FromEventPropertyDefinition>): FromEventPropertyDefinition {
+    return FromEventPropertyDefinition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<FromEventPropertyDefinition>): FromEventPropertyDefinition {
+    const message = createBaseFromEventPropertyDefinition();
+    message.Event = (object.Event !== undefined && object.Event !== null)
+      ? EventType.fromPartial(object.Event)
+      : undefined;
+    message.PropertyExpression = object.PropertyExpression ?? "";
+    return message;
+  },
+};
+
+function createBaseFromEveryDefinition(): FromEveryDefinition {
+  return { Properties: {}, IncludeChildren: false, AutoMap: 0, Key: "" };
+}
+
+export const FromEveryDefinition: MessageFns<FromEveryDefinition> = {
+  encode(message: FromEveryDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    globalThis.Object.entries(message.Properties).forEach(([key, value]: [string, string]) => {
+      FromEveryDefinition_PropertiesEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
+    });
+    if (message.IncludeChildren !== false) {
+      writer.uint32(16).bool(message.IncludeChildren);
+    }
+    if (message.AutoMap !== 0) {
+      writer.uint32(24).int32(message.AutoMap);
+    }
+    if (message.Key !== "") {
+      writer.uint32(34).string(message.Key);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): FromEveryDefinition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseFromEveryDefinition();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            const entry1 = FromEveryDefinition_PropertiesEntry.decode(reader, reader.uint32());
+            if (entry1.value !== undefined) {
+              message.Properties[entry1.key] = entry1.value;
+            }
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.IncludeChildren = reader.bool();
+            continue;
+          }
+          case 3: {
+            if (tag !== 24) {
+              break;
+            }
+
+            message.AutoMap = reader.int32() as any;
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.Key = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): FromEveryDefinition {
+    return {
+      Properties: isObject(object.Properties)
+        ? (globalThis.Object.entries(object.Properties) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: globalThis.String(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+      IncludeChildren: isSet(object.IncludeChildren) ? globalThis.Boolean(object.IncludeChildren) : false,
+      AutoMap: isSet(object.AutoMap) ? autoMapFromJSON(object.AutoMap) : 0,
+      Key: isSet(object.Key) ? globalThis.String(object.Key) : "",
+    };
+  },
+
+  toJSON(message: FromEveryDefinition): unknown {
+    const obj: any = {};
+    if (message.Properties) {
+      const entries = globalThis.Object.entries(message.Properties) as [string, string][];
+      if (entries.length > 0) {
+        obj.Properties = {};
+        entries.forEach(([k, v]) => {
+          obj.Properties[k] = v;
+        });
+      }
+    }
+    if (message.IncludeChildren !== false) {
+      obj.IncludeChildren = message.IncludeChildren;
+    }
+    if (message.AutoMap !== 0) {
+      obj.AutoMap = autoMapToJSON(message.AutoMap);
+    }
+    if (message.Key !== "") {
+      obj.Key = message.Key;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<FromEveryDefinition>): FromEveryDefinition {
+    return FromEveryDefinition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<FromEveryDefinition>): FromEveryDefinition {
+    const message = createBaseFromEveryDefinition();
+    message.Properties = (globalThis.Object.entries(object.Properties ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    message.IncludeChildren = object.IncludeChildren ?? false;
+    message.AutoMap = object.AutoMap ?? 0;
+    message.Key = object.Key ?? "";
+    return message;
+  },
+};
+
+function createBaseFromEveryDefinition_PropertiesEntry(): FromEveryDefinition_PropertiesEntry {
+  return { key: "", value: "" };
+}
+
+export const FromEveryDefinition_PropertiesEntry: MessageFns<FromEveryDefinition_PropertiesEntry> = {
+  encode(message: FromEveryDefinition_PropertiesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): FromEveryDefinition_PropertiesEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseFromEveryDefinition_PropertiesEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): FromEveryDefinition_PropertiesEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: FromEveryDefinition_PropertiesEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<FromEveryDefinition_PropertiesEntry>): FromEveryDefinition_PropertiesEntry {
+    return FromEveryDefinition_PropertiesEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<FromEveryDefinition_PropertiesEntry>): FromEveryDefinition_PropertiesEntry {
+    const message = createBaseFromEveryDefinition_PropertiesEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseGetAllDeclarationsRequest(): GetAllDeclarationsRequest {
+  return { EventStore: "" };
+}
+
+export const GetAllDeclarationsRequest: MessageFns<GetAllDeclarationsRequest> = {
+  encode(message: GetAllDeclarationsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetAllDeclarationsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGetAllDeclarationsRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.EventStore = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GetAllDeclarationsRequest {
+    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+  },
+
+  toJSON(message: GetAllDeclarationsRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetAllDeclarationsRequest>): GetAllDeclarationsRequest {
+    return GetAllDeclarationsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetAllDeclarationsRequest>): GetAllDeclarationsRequest {
+    const message = createBaseGetAllDeclarationsRequest();
+    message.EventStore = object.EventStore ?? "";
+    return message;
+  },
+};
+
+function createBaseGetAllDefinitionsRequest(): GetAllDefinitionsRequest {
+  return { EventStore: "" };
+}
+
+export const GetAllDefinitionsRequest: MessageFns<GetAllDefinitionsRequest> = {
+  encode(message: GetAllDefinitionsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetAllDefinitionsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGetAllDefinitionsRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.EventStore = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GetAllDefinitionsRequest {
+    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+  },
+
+  toJSON(message: GetAllDefinitionsRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetAllDefinitionsRequest>): GetAllDefinitionsRequest {
+    return GetAllDefinitionsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetAllDefinitionsRequest>): GetAllDefinitionsRequest {
+    const message = createBaseGetAllDefinitionsRequest();
+    message.EventStore = object.EventStore ?? "";
+    return message;
+  },
+};
+
+function createBaseGraphEdgeFromDefinition(): GraphEdgeFromDefinition {
+  return { SourceKey: "", TargetKey: "", Identity: "", Properties: {} };
+}
+
+export const GraphEdgeFromDefinition: MessageFns<GraphEdgeFromDefinition> = {
+  encode(message: GraphEdgeFromDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.SourceKey !== "") {
+      writer.uint32(10).string(message.SourceKey);
+    }
+    if (message.TargetKey !== "") {
+      writer.uint32(18).string(message.TargetKey);
+    }
+    if (message.Identity !== "") {
+      writer.uint32(26).string(message.Identity);
+    }
+    globalThis.Object.entries(message.Properties).forEach(([key, value]: [string, string]) => {
+      GraphEdgeFromDefinition_PropertiesEntry.encode({ key: key as any, value }, writer.uint32(34).fork()).join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphEdgeFromDefinition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphEdgeFromDefinition();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.SourceKey = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.TargetKey = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.Identity = reader.string();
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            const entry4 = GraphEdgeFromDefinition_PropertiesEntry.decode(reader, reader.uint32());
+            if (entry4.value !== undefined) {
+              message.Properties[entry4.key] = entry4.value;
+            }
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphEdgeFromDefinition {
+    return {
+      SourceKey: isSet(object.SourceKey) ? globalThis.String(object.SourceKey) : "",
+      TargetKey: isSet(object.TargetKey) ? globalThis.String(object.TargetKey) : "",
+      Identity: isSet(object.Identity) ? globalThis.String(object.Identity) : "",
+      Properties: isObject(object.Properties)
+        ? (globalThis.Object.entries(object.Properties) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: globalThis.String(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: GraphEdgeFromDefinition): unknown {
+    const obj: any = {};
+    if (message.SourceKey !== "") {
+      obj.SourceKey = message.SourceKey;
+    }
+    if (message.TargetKey !== "") {
+      obj.TargetKey = message.TargetKey;
+    }
+    if (message.Identity !== "") {
+      obj.Identity = message.Identity;
+    }
+    if (message.Properties) {
+      const entries = globalThis.Object.entries(message.Properties) as [string, string][];
+      if (entries.length > 0) {
+        obj.Properties = {};
+        entries.forEach(([k, v]) => {
+          obj.Properties[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GraphEdgeFromDefinition>): GraphEdgeFromDefinition {
+    return GraphEdgeFromDefinition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GraphEdgeFromDefinition>): GraphEdgeFromDefinition {
+    const message = createBaseGraphEdgeFromDefinition();
+    message.SourceKey = object.SourceKey ?? "";
+    message.TargetKey = object.TargetKey ?? "";
+    message.Identity = object.Identity ?? "";
+    message.Properties = (globalThis.Object.entries(object.Properties ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBaseGraphEdgeFromDefinition_PropertiesEntry(): GraphEdgeFromDefinition_PropertiesEntry {
+  return { key: "", value: "" };
+}
+
+export const GraphEdgeFromDefinition_PropertiesEntry: MessageFns<GraphEdgeFromDefinition_PropertiesEntry> = {
+  encode(message: GraphEdgeFromDefinition_PropertiesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphEdgeFromDefinition_PropertiesEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphEdgeFromDefinition_PropertiesEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphEdgeFromDefinition_PropertiesEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: GraphEdgeFromDefinition_PropertiesEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GraphEdgeFromDefinition_PropertiesEntry>): GraphEdgeFromDefinition_PropertiesEntry {
+    return GraphEdgeFromDefinition_PropertiesEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GraphEdgeFromDefinition_PropertiesEntry>): GraphEdgeFromDefinition_PropertiesEntry {
+    const message = createBaseGraphEdgeFromDefinition_PropertiesEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseGraphEdgeProjectionDefinition(): GraphEdgeProjectionDefinition {
+  return { From: {}, RemovedWith: {} };
+}
+
+export const GraphEdgeProjectionDefinition: MessageFns<GraphEdgeProjectionDefinition> = {
+  encode(message: GraphEdgeProjectionDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    globalThis.Object.entries(message.From).forEach(([key, value]: [string, GraphEdgeFromDefinition]) => {
+      GraphEdgeProjectionDefinition_FromEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
+    });
+    globalThis.Object.entries(message.RemovedWith).forEach(([key, value]: [string, GraphEdgeRemovedWithDefinition]) => {
+      GraphEdgeProjectionDefinition_RemovedWithEntry.encode({ key: key as any, value }, writer.uint32(18).fork())
+        .join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphEdgeProjectionDefinition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphEdgeProjectionDefinition();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            const entry1 = GraphEdgeProjectionDefinition_FromEntry.decode(reader, reader.uint32());
+            if (entry1.value !== undefined) {
+              message.From[entry1.key] = entry1.value;
+            }
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            const entry2 = GraphEdgeProjectionDefinition_RemovedWithEntry.decode(reader, reader.uint32());
+            if (entry2.value !== undefined) {
+              message.RemovedWith[entry2.key] = entry2.value;
+            }
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphEdgeProjectionDefinition {
+    return {
+      From: isObject(object.From)
+        ? (globalThis.Object.entries(object.From) as [string, any][]).reduce(
+          (acc: { [key: string]: GraphEdgeFromDefinition }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: GraphEdgeFromDefinition.fromJSON(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+      RemovedWith: isObject(object.RemovedWith)
+        ? (globalThis.Object.entries(object.RemovedWith) as [string, any][]).reduce(
+          (acc: { [key: string]: GraphEdgeRemovedWithDefinition }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: GraphEdgeRemovedWithDefinition.fromJSON(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: GraphEdgeProjectionDefinition): unknown {
+    const obj: any = {};
+    if (message.From) {
+      const entries = globalThis.Object.entries(message.From) as [string, GraphEdgeFromDefinition][];
+      if (entries.length > 0) {
+        obj.From = {};
+        entries.forEach(([k, v]) => {
+          obj.From[k] = GraphEdgeFromDefinition.toJSON(v);
+        });
+      }
+    }
+    if (message.RemovedWith) {
+      const entries = globalThis.Object.entries(message.RemovedWith) as [string, GraphEdgeRemovedWithDefinition][];
+      if (entries.length > 0) {
+        obj.RemovedWith = {};
+        entries.forEach(([k, v]) => {
+          obj.RemovedWith[k] = GraphEdgeRemovedWithDefinition.toJSON(v);
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GraphEdgeProjectionDefinition>): GraphEdgeProjectionDefinition {
+    return GraphEdgeProjectionDefinition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GraphEdgeProjectionDefinition>): GraphEdgeProjectionDefinition {
+    const message = createBaseGraphEdgeProjectionDefinition();
+    message.From = (globalThis.Object.entries(object.From ?? {}) as [string, GraphEdgeFromDefinition][]).reduce(
+      (acc: { [key: string]: GraphEdgeFromDefinition }, [key, value]: [string, GraphEdgeFromDefinition]) => {
+        if (value !== undefined) {
+          acc[key] = GraphEdgeFromDefinition.fromPartial(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    message.RemovedWith =
+      (globalThis.Object.entries(object.RemovedWith ?? {}) as [string, GraphEdgeRemovedWithDefinition][]).reduce(
+        (
+          acc: { [key: string]: GraphEdgeRemovedWithDefinition },
+          [key, value]: [string, GraphEdgeRemovedWithDefinition],
+        ) => {
+          if (value !== undefined) {
+            acc[key] = GraphEdgeRemovedWithDefinition.fromPartial(value);
+          }
+          return acc;
+        },
+        {},
+      );
+    return message;
+  },
+};
+
+function createBaseGraphEdgeProjectionDefinition_FromEntry(): GraphEdgeProjectionDefinition_FromEntry {
+  return { key: "", value: undefined };
+}
+
+export const GraphEdgeProjectionDefinition_FromEntry: MessageFns<GraphEdgeProjectionDefinition_FromEntry> = {
+  encode(message: GraphEdgeProjectionDefinition_FromEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== undefined) {
+      GraphEdgeFromDefinition.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphEdgeProjectionDefinition_FromEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphEdgeProjectionDefinition_FromEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = GraphEdgeFromDefinition.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphEdgeProjectionDefinition_FromEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? GraphEdgeFromDefinition.fromJSON(object.value) : undefined,
+    };
+  },
+
+  toJSON(message: GraphEdgeProjectionDefinition_FromEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== undefined) {
+      obj.value = GraphEdgeFromDefinition.toJSON(message.value);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GraphEdgeProjectionDefinition_FromEntry>): GraphEdgeProjectionDefinition_FromEntry {
+    return GraphEdgeProjectionDefinition_FromEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GraphEdgeProjectionDefinition_FromEntry>): GraphEdgeProjectionDefinition_FromEntry {
+    const message = createBaseGraphEdgeProjectionDefinition_FromEntry();
+    message.key = object.key ?? "";
+    message.value = (object.value !== undefined && object.value !== null)
+      ? GraphEdgeFromDefinition.fromPartial(object.value)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGraphEdgeProjectionDefinition_RemovedWithEntry(): GraphEdgeProjectionDefinition_RemovedWithEntry {
+  return { key: "", value: undefined };
+}
+
+export const GraphEdgeProjectionDefinition_RemovedWithEntry: MessageFns<
+  GraphEdgeProjectionDefinition_RemovedWithEntry
+> = {
+  encode(
+    message: GraphEdgeProjectionDefinition_RemovedWithEntry,
+    writer: BinaryWriter = new BinaryWriter(),
+  ): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== undefined) {
+      GraphEdgeRemovedWithDefinition.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphEdgeProjectionDefinition_RemovedWithEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphEdgeProjectionDefinition_RemovedWithEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = GraphEdgeRemovedWithDefinition.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphEdgeProjectionDefinition_RemovedWithEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? GraphEdgeRemovedWithDefinition.fromJSON(object.value) : undefined,
+    };
+  },
+
+  toJSON(message: GraphEdgeProjectionDefinition_RemovedWithEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== undefined) {
+      obj.value = GraphEdgeRemovedWithDefinition.toJSON(message.value);
+    }
+    return obj;
+  },
+
+  create(
+    base?: DeepPartial<GraphEdgeProjectionDefinition_RemovedWithEntry>,
+  ): GraphEdgeProjectionDefinition_RemovedWithEntry {
+    return GraphEdgeProjectionDefinition_RemovedWithEntry.fromPartial(base ?? {});
+  },
+  fromPartial(
+    object: DeepPartial<GraphEdgeProjectionDefinition_RemovedWithEntry>,
+  ): GraphEdgeProjectionDefinition_RemovedWithEntry {
+    const message = createBaseGraphEdgeProjectionDefinition_RemovedWithEntry();
+    message.key = object.key ?? "";
+    message.value = (object.value !== undefined && object.value !== null)
+      ? GraphEdgeRemovedWithDefinition.fromPartial(object.value)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGraphEdgeRemovedWithDefinition(): GraphEdgeRemovedWithDefinition {
+  return { SourceKey: "", TargetKey: "", Identity: "" };
+}
+
+export const GraphEdgeRemovedWithDefinition: MessageFns<GraphEdgeRemovedWithDefinition> = {
+  encode(message: GraphEdgeRemovedWithDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.SourceKey !== "") {
+      writer.uint32(10).string(message.SourceKey);
+    }
+    if (message.TargetKey !== "") {
+      writer.uint32(18).string(message.TargetKey);
+    }
+    if (message.Identity !== "") {
+      writer.uint32(26).string(message.Identity);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphEdgeRemovedWithDefinition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphEdgeRemovedWithDefinition();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.SourceKey = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.TargetKey = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.Identity = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphEdgeRemovedWithDefinition {
+    return {
+      SourceKey: isSet(object.SourceKey) ? globalThis.String(object.SourceKey) : "",
+      TargetKey: isSet(object.TargetKey) ? globalThis.String(object.TargetKey) : "",
+      Identity: isSet(object.Identity) ? globalThis.String(object.Identity) : "",
+    };
+  },
+
+  toJSON(message: GraphEdgeRemovedWithDefinition): unknown {
+    const obj: any = {};
+    if (message.SourceKey !== "") {
+      obj.SourceKey = message.SourceKey;
+    }
+    if (message.TargetKey !== "") {
+      obj.TargetKey = message.TargetKey;
+    }
+    if (message.Identity !== "") {
+      obj.Identity = message.Identity;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GraphEdgeRemovedWithDefinition>): GraphEdgeRemovedWithDefinition {
+    return GraphEdgeRemovedWithDefinition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GraphEdgeRemovedWithDefinition>): GraphEdgeRemovedWithDefinition {
+    const message = createBaseGraphEdgeRemovedWithDefinition();
+    message.SourceKey = object.SourceKey ?? "";
+    message.TargetKey = object.TargetKey ?? "";
+    message.Identity = object.Identity ?? "";
+    return message;
+  },
+};
+
+function createBaseGraphNodeFromDefinition(): GraphNodeFromDefinition {
+  return { Key: "", Properties: {}, UpdateOnly: false };
+}
+
+export const GraphNodeFromDefinition: MessageFns<GraphNodeFromDefinition> = {
+  encode(message: GraphNodeFromDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Key !== "") {
+      writer.uint32(10).string(message.Key);
+    }
+    globalThis.Object.entries(message.Properties).forEach(([key, value]: [string, string]) => {
+      GraphNodeFromDefinition_PropertiesEntry.encode({ key: key as any, value }, writer.uint32(18).fork()).join();
+    });
+    if (message.UpdateOnly !== false) {
+      writer.uint32(24).bool(message.UpdateOnly);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphNodeFromDefinition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphNodeFromDefinition();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.Key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            const entry2 = GraphNodeFromDefinition_PropertiesEntry.decode(reader, reader.uint32());
+            if (entry2.value !== undefined) {
+              message.Properties[entry2.key] = entry2.value;
+            }
+            continue;
+          }
+          case 3: {
+            if (tag !== 24) {
+              break;
+            }
+
+            message.UpdateOnly = reader.bool();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphNodeFromDefinition {
+    return {
+      Key: isSet(object.Key) ? globalThis.String(object.Key) : "",
+      Properties: isObject(object.Properties)
+        ? (globalThis.Object.entries(object.Properties) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: globalThis.String(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+      UpdateOnly: isSet(object.UpdateOnly) ? globalThis.Boolean(object.UpdateOnly) : false,
+    };
+  },
+
+  toJSON(message: GraphNodeFromDefinition): unknown {
+    const obj: any = {};
+    if (message.Key !== "") {
+      obj.Key = message.Key;
+    }
+    if (message.Properties) {
+      const entries = globalThis.Object.entries(message.Properties) as [string, string][];
+      if (entries.length > 0) {
+        obj.Properties = {};
+        entries.forEach(([k, v]) => {
+          obj.Properties[k] = v;
+        });
+      }
+    }
+    if (message.UpdateOnly !== false) {
+      obj.UpdateOnly = message.UpdateOnly;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GraphNodeFromDefinition>): GraphNodeFromDefinition {
+    return GraphNodeFromDefinition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GraphNodeFromDefinition>): GraphNodeFromDefinition {
+    const message = createBaseGraphNodeFromDefinition();
+    message.Key = object.Key ?? "";
+    message.Properties = (globalThis.Object.entries(object.Properties ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    message.UpdateOnly = object.UpdateOnly ?? false;
+    return message;
+  },
+};
+
+function createBaseGraphNodeFromDefinition_PropertiesEntry(): GraphNodeFromDefinition_PropertiesEntry {
+  return { key: "", value: "" };
+}
+
+export const GraphNodeFromDefinition_PropertiesEntry: MessageFns<GraphNodeFromDefinition_PropertiesEntry> = {
+  encode(message: GraphNodeFromDefinition_PropertiesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphNodeFromDefinition_PropertiesEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphNodeFromDefinition_PropertiesEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphNodeFromDefinition_PropertiesEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: GraphNodeFromDefinition_PropertiesEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GraphNodeFromDefinition_PropertiesEntry>): GraphNodeFromDefinition_PropertiesEntry {
+    return GraphNodeFromDefinition_PropertiesEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GraphNodeFromDefinition_PropertiesEntry>): GraphNodeFromDefinition_PropertiesEntry {
+    const message = createBaseGraphNodeFromDefinition_PropertiesEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseGraphNodeProjectionDefinition(): GraphNodeProjectionDefinition {
+  return { From: {}, RemovedWith: {} };
+}
+
+export const GraphNodeProjectionDefinition: MessageFns<GraphNodeProjectionDefinition> = {
+  encode(message: GraphNodeProjectionDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    globalThis.Object.entries(message.From).forEach(([key, value]: [string, GraphNodeFromDefinition]) => {
+      GraphNodeProjectionDefinition_FromEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
+    });
+    globalThis.Object.entries(message.RemovedWith).forEach(([key, value]: [string, GraphNodeRemovedWithDefinition]) => {
+      GraphNodeProjectionDefinition_RemovedWithEntry.encode({ key: key as any, value }, writer.uint32(18).fork())
+        .join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphNodeProjectionDefinition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphNodeProjectionDefinition();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            const entry1 = GraphNodeProjectionDefinition_FromEntry.decode(reader, reader.uint32());
+            if (entry1.value !== undefined) {
+              message.From[entry1.key] = entry1.value;
+            }
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            const entry2 = GraphNodeProjectionDefinition_RemovedWithEntry.decode(reader, reader.uint32());
+            if (entry2.value !== undefined) {
+              message.RemovedWith[entry2.key] = entry2.value;
+            }
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphNodeProjectionDefinition {
+    return {
+      From: isObject(object.From)
+        ? (globalThis.Object.entries(object.From) as [string, any][]).reduce(
+          (acc: { [key: string]: GraphNodeFromDefinition }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: GraphNodeFromDefinition.fromJSON(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+      RemovedWith: isObject(object.RemovedWith)
+        ? (globalThis.Object.entries(object.RemovedWith) as [string, any][]).reduce(
+          (acc: { [key: string]: GraphNodeRemovedWithDefinition }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: GraphNodeRemovedWithDefinition.fromJSON(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: GraphNodeProjectionDefinition): unknown {
+    const obj: any = {};
+    if (message.From) {
+      const entries = globalThis.Object.entries(message.From) as [string, GraphNodeFromDefinition][];
+      if (entries.length > 0) {
+        obj.From = {};
+        entries.forEach(([k, v]) => {
+          obj.From[k] = GraphNodeFromDefinition.toJSON(v);
+        });
+      }
+    }
+    if (message.RemovedWith) {
+      const entries = globalThis.Object.entries(message.RemovedWith) as [string, GraphNodeRemovedWithDefinition][];
+      if (entries.length > 0) {
+        obj.RemovedWith = {};
+        entries.forEach(([k, v]) => {
+          obj.RemovedWith[k] = GraphNodeRemovedWithDefinition.toJSON(v);
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GraphNodeProjectionDefinition>): GraphNodeProjectionDefinition {
+    return GraphNodeProjectionDefinition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GraphNodeProjectionDefinition>): GraphNodeProjectionDefinition {
+    const message = createBaseGraphNodeProjectionDefinition();
+    message.From = (globalThis.Object.entries(object.From ?? {}) as [string, GraphNodeFromDefinition][]).reduce(
+      (acc: { [key: string]: GraphNodeFromDefinition }, [key, value]: [string, GraphNodeFromDefinition]) => {
+        if (value !== undefined) {
+          acc[key] = GraphNodeFromDefinition.fromPartial(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    message.RemovedWith =
+      (globalThis.Object.entries(object.RemovedWith ?? {}) as [string, GraphNodeRemovedWithDefinition][]).reduce(
+        (
+          acc: { [key: string]: GraphNodeRemovedWithDefinition },
+          [key, value]: [string, GraphNodeRemovedWithDefinition],
+        ) => {
+          if (value !== undefined) {
+            acc[key] = GraphNodeRemovedWithDefinition.fromPartial(value);
+          }
+          return acc;
+        },
+        {},
+      );
+    return message;
+  },
+};
+
+function createBaseGraphNodeProjectionDefinition_FromEntry(): GraphNodeProjectionDefinition_FromEntry {
+  return { key: "", value: undefined };
+}
+
+export const GraphNodeProjectionDefinition_FromEntry: MessageFns<GraphNodeProjectionDefinition_FromEntry> = {
+  encode(message: GraphNodeProjectionDefinition_FromEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== undefined) {
+      GraphNodeFromDefinition.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphNodeProjectionDefinition_FromEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphNodeProjectionDefinition_FromEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = GraphNodeFromDefinition.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphNodeProjectionDefinition_FromEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? GraphNodeFromDefinition.fromJSON(object.value) : undefined,
+    };
+  },
+
+  toJSON(message: GraphNodeProjectionDefinition_FromEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== undefined) {
+      obj.value = GraphNodeFromDefinition.toJSON(message.value);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GraphNodeProjectionDefinition_FromEntry>): GraphNodeProjectionDefinition_FromEntry {
+    return GraphNodeProjectionDefinition_FromEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GraphNodeProjectionDefinition_FromEntry>): GraphNodeProjectionDefinition_FromEntry {
+    const message = createBaseGraphNodeProjectionDefinition_FromEntry();
+    message.key = object.key ?? "";
+    message.value = (object.value !== undefined && object.value !== null)
+      ? GraphNodeFromDefinition.fromPartial(object.value)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGraphNodeProjectionDefinition_RemovedWithEntry(): GraphNodeProjectionDefinition_RemovedWithEntry {
+  return { key: "", value: undefined };
+}
+
+export const GraphNodeProjectionDefinition_RemovedWithEntry: MessageFns<
+  GraphNodeProjectionDefinition_RemovedWithEntry
+> = {
+  encode(
+    message: GraphNodeProjectionDefinition_RemovedWithEntry,
+    writer: BinaryWriter = new BinaryWriter(),
+  ): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== undefined) {
+      GraphNodeRemovedWithDefinition.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphNodeProjectionDefinition_RemovedWithEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseGraphNodeProjectionDefinition_RemovedWithEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = GraphNodeRemovedWithDefinition.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): GraphNodeProjectionDefinition_RemovedWithEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? GraphNodeRemovedWithDefinition.fromJSON(object.value) : undefined,
+    };
+  },
+
+  toJSON(message: GraphNodeProjectionDefinition_RemovedWithEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== undefined) {
+      obj.value = GraphNodeRemovedWithDefinition.toJSON(message.value);
+    }
+    return obj;
+  },
+
+  create(
+    base?: DeepPartial<GraphNodeProjectionDefinition_RemovedWithEntry>,
+  ): GraphNodeProjectionDefinition_RemovedWithEntry {
+    return GraphNodeProjectionDefinition_RemovedWithEntry.fromPartial(base ?? {});
+  },
+  fromPartial(
+    object: DeepPartial<GraphNodeProjectionDefinition_RemovedWithEntry>,
+  ): GraphNodeProjectionDefinition_RemovedWithEntry {
+    const message = createBaseGraphNodeProjectionDefinition_RemovedWithEntry();
+    message.key = object.key ?? "";
+    message.value = (object.value !== undefined && object.value !== null)
+      ? GraphNodeRemovedWithDefinition.fromPartial(object.value)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGraphNodeRemovedWithDefinition(): GraphNodeRemovedWithDefinition {
+  return { Key: "", Detach: false };
+}
+
+export const GraphNodeRemovedWithDefinition: MessageFns<GraphNodeRemovedWithDefinition> = {
+  encode(message: GraphNodeRemovedWithDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Key !== "") {
+      writer.uint32(10).string(message.Key);
     }
-    if (message.PropertyExpression !== "") {
-      writer.uint32(18).string(message.PropertyExpression);
+    if (message.Detach !== false) {
+      writer.uint32(16).bool(message.Detach);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): FromEventPropertyDefinition {
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphNodeRemovedWithDefinition {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -1667,7 +3415,7 @@ export const FromEventPropertyDefinition: MessageFns<FromEventPropertyDefinition
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseFromEventPropertyDefinition();
+      const message = createBaseGraphNodeRemovedWithDefinition();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -1676,15 +3424,15 @@ export const FromEventPropertyDefinition: MessageFns<FromEventPropertyDefinition
               break;
             }
 
-            message.Event = EventType.decode(reader, reader.uint32());
+            message.Key = reader.string();
             continue;
           }
           case 2: {
-            if (tag !== 18) {
+            if (tag !== 16) {
               break;
             }
 
-            message.PropertyExpression = reader.string();
+            message.Detach = reader.bool();
             continue;
           }
         }
@@ -1699,59 +3447,51 @@ export const FromEventPropertyDefinition: MessageFns<FromEventPropertyDefinition
     }
   },
 
-  fromJSON(object: any): FromEventPropertyDefinition {
+  fromJSON(object: any): GraphNodeRemovedWithDefinition {
     return {
-      Event: isSet(object.Event) ? EventType.fromJSON(object.Event) : undefined,
-      PropertyExpression: isSet(object.PropertyExpression) ? globalThis.String(object.PropertyExpression) : "",
+      Key: isSet(object.Key) ? globalThis.String(object.Key) : "",
+      Detach: isSet(object.Detach) ? globalThis.Boolean(object.Detach) : false,
     };
   },
 
-  toJSON(message: FromEventPropertyDefinition): unknown {
+  toJSON(message: GraphNodeRemovedWithDefinition): unknown {
     const obj: any = {};
-    if (message.Event !== undefined) {
-      obj.Event = EventType.toJSON(message.Event);
+    if (message.Key !== "") {
+      obj.Key = message.Key;
     }
-    if (message.PropertyExpression !== "") {
-      obj.PropertyExpression = message.PropertyExpression;
+    if (message.Detach !== false) {
+      obj.Detach = message.Detach;
     }
     return obj;
   },
 
-  create(base?: DeepPartial<FromEventPropertyDefinition>): FromEventPropertyDefinition {
-    return FromEventPropertyDefinition.fromPartial(base ?? {});
+  create(base?: DeepPartial<GraphNodeRemovedWithDefinition>): GraphNodeRemovedWithDefinition {
+    return GraphNodeRemovedWithDefinition.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<FromEventPropertyDefinition>): FromEventPropertyDefinition {
-    const message = createBaseFromEventPropertyDefinition();
-    message.Event = (object.Event !== undefined && object.Event !== null)
-      ? EventType.fromPartial(object.Event)
-      : undefined;
-    message.PropertyExpression = object.PropertyExpression ?? "";
+  fromPartial(object: DeepPartial<GraphNodeRemovedWithDefinition>): GraphNodeRemovedWithDefinition {
+    const message = createBaseGraphNodeRemovedWithDefinition();
+    message.Key = object.Key ?? "";
+    message.Detach = object.Detach ?? false;
     return message;
   },
 };
 
-function createBaseFromEveryDefinition(): FromEveryDefinition {
-  return { Properties: {}, IncludeChildren: false, AutoMap: 0, Key: "" };
+function createBaseGraphProjectionDefinition(): GraphProjectionDefinition {
+  return { Nodes: {}, Edges: {} };
 }
 
-export const FromEveryDefinition: MessageFns<FromEveryDefinition> = {
-  encode(message: FromEveryDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    globalThis.Object.entries(message.Properties).forEach(([key, value]: [string, string]) => {
-      FromEveryDefinition_PropertiesEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
+export const GraphProjectionDefinition: MessageFns<GraphProjectionDefinition> = {
+  encode(message: GraphProjectionDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    globalThis.Object.entries(message.Nodes).forEach(([key, value]: [string, GraphNodeProjectionDefinition]) => {
+      GraphProjectionDefinition_NodesEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
+    });
+    globalThis.Object.entries(message.Edges).forEach(([key, value]: [string, GraphEdgeProjectionDefinition]) => {
+      GraphProjectionDefinition_EdgesEntry.encode({ key: key as any, value }, writer.uint32(18).fork()).join();
     });
-    if (message.IncludeChildren !== false) {
-      writer.uint32(16).bool(message.IncludeChildren);
-    }
-    if (message.AutoMap !== 0) {
-      writer.uint32(24).int32(message.AutoMap);
-    }
-    if (message.Key !== "") {
-      writer.uint32(34).string(message.Key);
-    }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): FromEveryDefinition {
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphProjectionDefinition {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -1760,7 +3500,7 @@ export const FromEveryDefinition: MessageFns<FromEveryDefinition> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseFromEveryDefinition();
+      const message = createBaseGraphProjectionDefinition();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -1769,34 +3509,21 @@ export const FromEveryDefinition: MessageFns<FromEveryDefinition> = {
               break;
             }
 
-            const entry1 = FromEveryDefinition_PropertiesEntry.decode(reader, reader.uint32());
+            const entry1 = GraphProjectionDefinition_NodesEntry.decode(reader, reader.uint32());
             if (entry1.value !== undefined) {
-              message.Properties[entry1.key] = entry1.value;
+              message.Nodes[entry1.key] = entry1.value;
             }
             continue;
           }
           case 2: {
-            if (tag !== 16) {
-              break;
-            }
-
-            message.IncludeChildren = reader.bool();
-            continue;
-          }
-          case 3: {
-            if (tag !== 24) {
+            if (tag !== 18) {
               break;
             }
 
-            message.AutoMap = reader.int32() as any;
-            continue;
-          }
-          case 4: {
-            if (tag !== 34) {
-              break;
+            const entry2 = GraphProjectionDefinition_EdgesEntry.decode(reader, reader.uint32());
+            if (entry2.value !== undefined) {
+              message.Edges[entry2.key] = entry2.value;
             }
-
-            message.Key = reader.string();
             continue;
           }
         }
@@ -1811,13 +3538,27 @@ export const FromEveryDefinition: MessageFns<FromEveryDefinition> = {
     }
   },
 
-  fromJSON(object: any): FromEveryDefinition {
+  fromJSON(object: any): GraphProjectionDefinition {
     return {
-      Properties: isObject(object.Properties)
-        ? (globalThis.Object.entries(object.Properties) as [string, any][]).reduce(
-          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+      Nodes: isObject(object.Nodes)
+        ? (globalThis.Object.entries(object.Nodes) as [string, any][]).reduce(
+          (acc: { [key: string]: GraphNodeProjectionDefinition }, [key, value]: [string, any]) => {
             globalThis.Object.defineProperty(acc, key, {
-              value: globalThis.String(value),
+              value: GraphNodeProjectionDefinition.fromJSON(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+      Edges: isObject(object.Edges)
+        ? (globalThis.Object.entries(object.Edges) as [string, any][]).reduce(
+          (acc: { [key: string]: GraphEdgeProjectionDefinition }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: GraphEdgeProjectionDefinition.fromJSON(value),
               enumerable: true,
               configurable: true,
               writable: true,
@@ -1827,72 +3568,81 @@ export const FromEveryDefinition: MessageFns<FromEveryDefinition> = {
           {},
         )
         : {},
-      IncludeChildren: isSet(object.IncludeChildren) ? globalThis.Boolean(object.IncludeChildren) : false,
-      AutoMap: isSet(object.AutoMap) ? autoMapFromJSON(object.AutoMap) : 0,
-      Key: isSet(object.Key) ? globalThis.String(object.Key) : "",
     };
   },
 
-  toJSON(message: FromEveryDefinition): unknown {
+  toJSON(message: GraphProjectionDefinition): unknown {
     const obj: any = {};
-    if (message.Properties) {
-      const entries = globalThis.Object.entries(message.Properties) as [string, string][];
+    if (message.Nodes) {
+      const entries = globalThis.Object.entries(message.Nodes) as [string, GraphNodeProjectionDefinition][];
       if (entries.length > 0) {
-        obj.Properties = {};
+        obj.Nodes = {};
         entries.forEach(([k, v]) => {
-          obj.Properties[k] = v;
+          obj.Nodes[k] = GraphNodeProjectionDefinition.toJSON(v);
         });
       }
     }
-    if (message.IncludeChildren !== false) {
-      obj.IncludeChildren = message.IncludeChildren;
-    }
-    if (message.AutoMap !== 0) {
-      obj.AutoMap = autoMapToJSON(message.AutoMap);
-    }
-    if (message.Key !== "") {
-      obj.Key = message.Key;
+    if (message.Edges) {
+      const entries = globalThis.Object.entries(message.Edges) as [string, GraphEdgeProjectionDefinition][];
+      if (entries.length > 0) {
+        obj.Edges = {};
+        entries.forEach(([k, v]) => {
+          obj.Edges[k] = GraphEdgeProjectionDefinition.toJSON(v);
+        });
+      }
     }
     return obj;
   },
 
-  create(base?: DeepPartial<FromEveryDefinition>): FromEveryDefinition {
-    return FromEveryDefinition.fromPartial(base ?? {});
+  create(base?: DeepPartial<GraphProjectionDefinition>): GraphProjectionDefinition {
+    return GraphProjectionDefinition.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<FromEveryDefinition>): FromEveryDefinition {
-    const message = createBaseFromEveryDefinition();
-    message.Properties = (globalThis.Object.entries(object.Properties ?? {}) as [string, string][]).reduce(
-      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+  fromPartial(object: DeepPartial<GraphProjectionDefinition>): GraphProjectionDefinition {
+    const message = createBaseGraphProjectionDefinition();
+    message.Nodes = (globalThis.Object.entries(object.Nodes ?? {}) as [string, GraphNodeProjectionDefinition][]).reduce(
+      (
+        acc: { [key: string]: GraphNodeProjectionDefinition },
+        [key, value]: [string, GraphNodeProjectionDefinition],
+      ) => {
         if (value !== undefined) {
-          acc[key] = globalThis.String(value);
+          acc[key] = GraphNodeProjectionDefinition.fromPartial(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    message.Edges = (globalThis.Object.entries(object.Edges ?? {}) as [string, GraphEdgeProjectionDefinition][]).reduce(
+      (
+        acc: { [key: string]: GraphEdgeProjectionDefinition },
+        [key, value]: [string, GraphEdgeProjectionDefinition],
+      ) => {
+        if (value !== undefined) {
+          acc[key] = GraphEdgeProjectionDefinition.fromPartial(value);
         }
         return acc;
       },
       {},
     );
-    message.IncludeChildren = object.IncludeChildren ?? false;
-    message.AutoMap = object.AutoMap ?? 0;
-    message.Key = object.Key ?? "";
     return message;
   },
 };
 
-function createBaseFromEveryDefinition_PropertiesEntry(): FromEveryDefinition_PropertiesEntry {
-  return { key: "", value: "" };
+function createBaseGraphProjectionDefinition_NodesEntry(): GraphProjectionDefinition_NodesEntry {
+  return { key: "", value: undefined };
 }
 
-export const FromEveryDefinition_PropertiesEntry: MessageFns<FromEveryDefinition_PropertiesEntry> = {
-  encode(message: FromEveryDefinition_PropertiesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const GraphProjectionDefinition_NodesEntry: MessageFns<GraphProjectionDefinition_NodesEntry> = {
+  encode(message: GraphProjectionDefinition_NodesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.key !== "") {
       writer.uint32(10).string(message.key);
     }
-    if (message.value !== "") {
-      writer.uint32(18).string(message.value);
+    if (message.value !== undefined) {
+      GraphNodeProjectionDefinition.encode(message.value, writer.uint32(18).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): FromEveryDefinition_PropertiesEntry {
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphProjectionDefinition_NodesEntry {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -1901,7 +3651,7 @@ export const FromEveryDefinition_PropertiesEntry: MessageFns<FromEveryDefinition
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseFromEveryDefinition_PropertiesEntry();
+      const message = createBaseGraphProjectionDefinition_NodesEntry();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -1918,7 +3668,7 @@ export const FromEveryDefinition_PropertiesEntry: MessageFns<FromEveryDefinition
               break;
             }
 
-            message.value = reader.string();
+            message.value = GraphNodeProjectionDefinition.decode(reader, reader.uint32());
             continue;
           }
         }
@@ -1933,48 +3683,53 @@ export const FromEveryDefinition_PropertiesEntry: MessageFns<FromEveryDefinition
     }
   },
 
-  fromJSON(object: any): FromEveryDefinition_PropertiesEntry {
+  fromJSON(object: any): GraphProjectionDefinition_NodesEntry {
     return {
       key: isSet(object.key) ? globalThis.String(object.key) : "",
-      value: isSet(object.value) ? globalThis.String(object.value) : "",
+      value: isSet(object.value) ? GraphNodeProjectionDefinition.fromJSON(object.value) : undefined,
     };
   },
 
-  toJSON(message: FromEveryDefinition_PropertiesEntry): unknown {
+  toJSON(message: GraphProjectionDefinition_NodesEntry): unknown {
     const obj: any = {};
     if (message.key !== "") {
       obj.key = message.key;
     }
-    if (message.value !== "") {
-      obj.value = message.value;
+    if (message.value !== undefined) {
+      obj.value = GraphNodeProjectionDefinition.toJSON(message.value);
     }
     return obj;
   },
 
-  create(base?: DeepPartial<FromEveryDefinition_PropertiesEntry>): FromEveryDefinition_PropertiesEntry {
-    return FromEveryDefinition_PropertiesEntry.fromPartial(base ?? {});
+  create(base?: DeepPartial<GraphProjectionDefinition_NodesEntry>): GraphProjectionDefinition_NodesEntry {
+    return GraphProjectionDefinition_NodesEntry.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<FromEveryDefinition_PropertiesEntry>): FromEveryDefinition_PropertiesEntry {
-    const message = createBaseFromEveryDefinition_PropertiesEntry();
+  fromPartial(object: DeepPartial<GraphProjectionDefinition_NodesEntry>): GraphProjectionDefinition_NodesEntry {
+    const message = createBaseGraphProjectionDefinition_NodesEntry();
     message.key = object.key ?? "";
-    message.value = object.value ?? "";
+    message.value = (object.value !== undefined && object.value !== null)
+      ? GraphNodeProjectionDefinition.fromPartial(object.value)
+      : undefined;
     return message;
   },
 };
 
-function createBaseGetAllDeclarationsRequest(): GetAllDeclarationsRequest {
-  return { EventStore: "" };
+function createBaseGraphProjectionDefinition_EdgesEntry(): GraphProjectionDefinition_EdgesEntry {
+  return { key: "", value: undefined };
 }
 
-export const GetAllDeclarationsRequest: MessageFns<GetAllDeclarationsRequest> = {
-  encode(message: GetAllDeclarationsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.EventStore !== "") {
-      writer.uint32(10).string(message.EventStore);
+export const GraphProjectionDefinition_EdgesEntry: MessageFns<GraphProjectionDefinition_EdgesEntry> = {
+  encode(message: GraphProjectionDefinition_EdgesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== undefined) {
+      GraphEdgeProjectionDefinition.encode(message.value, writer.uint32(18).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): GetAllDeclarationsRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): GraphProjectionDefinition_EdgesEntry {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -1983,7 +3738,7 @@ export const GetAllDeclarationsRequest: MessageFns<GetAllDeclarationsRequest> =
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseGetAllDeclarationsRequest();
+      const message = createBaseGraphProjectionDefinition_EdgesEntry();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -1992,74 +3747,15 @@ export const GetAllDeclarationsRequest: MessageFns<GetAllDeclarationsRequest> =
               break;
             }
 
-            message.EventStore = reader.string();
+            message.key = reader.string();
             continue;
           }
-        }
-        if ((tag & 7) === 4 || tag === 0) {
-          break;
-        }
-        reader.skip(tag & 7);
-      }
-      return message;
-    } finally {
-      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
-    }
-  },
-
-  fromJSON(object: any): GetAllDeclarationsRequest {
-    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
-  },
-
-  toJSON(message: GetAllDeclarationsRequest): unknown {
-    const obj: any = {};
-    if (message.EventStore !== "") {
-      obj.EventStore = message.EventStore;
-    }
-    return obj;
-  },
-
-  create(base?: DeepPartial<GetAllDeclarationsRequest>): GetAllDeclarationsRequest {
-    return GetAllDeclarationsRequest.fromPartial(base ?? {});
-  },
-  fromPartial(object: DeepPartial<GetAllDeclarationsRequest>): GetAllDeclarationsRequest {
-    const message = createBaseGetAllDeclarationsRequest();
-    message.EventStore = object.EventStore ?? "";
-    return message;
-  },
-};
-
-function createBaseGetAllDefinitionsRequest(): GetAllDefinitionsRequest {
-  return { EventStore: "" };
-}
-
-export const GetAllDefinitionsRequest: MessageFns<GetAllDefinitionsRequest> = {
-  encode(message: GetAllDefinitionsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.EventStore !== "") {
-      writer.uint32(10).string(message.EventStore);
-    }
-    return writer;
-  },
-
-  decode(input: BinaryReader | Uint8Array, length?: number): GetAllDefinitionsRequest {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
-    if (previousRecursionDepth >= 100) {
-      throw new globalThis.Error("protobuf decode recursion limit exceeded");
-    }
-    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
-    try {
-      const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseGetAllDefinitionsRequest();
-      while (reader.pos < end) {
-        const tag = reader.uint32();
-        switch (tag >>> 3) {
-          case 1: {
-            if (tag !== 10) {
+          case 2: {
+            if (tag !== 18) {
               break;
             }
 
-            message.EventStore = reader.string();
+            message.value = GraphEdgeProjectionDefinition.decode(reader, reader.uint32());
             continue;
           }
         }
@@ -2074,24 +3770,33 @@ export const GetAllDefinitionsRequest: MessageFns<GetAllDefinitionsRequest> = {
     }
   },
 
-  fromJSON(object: any): GetAllDefinitionsRequest {
-    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+  fromJSON(object: any): GraphProjectionDefinition_EdgesEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? GraphEdgeProjectionDefinition.fromJSON(object.value) : undefined,
+    };
   },
 
-  toJSON(message: GetAllDefinitionsRequest): unknown {
+  toJSON(message: GraphProjectionDefinition_EdgesEntry): unknown {
     const obj: any = {};
-    if (message.EventStore !== "") {
-      obj.EventStore = message.EventStore;
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== undefined) {
+      obj.value = GraphEdgeProjectionDefinition.toJSON(message.value);
     }
     return obj;
   },
 
-  create(base?: DeepPartial<GetAllDefinitionsRequest>): GetAllDefinitionsRequest {
-    return GetAllDefinitionsRequest.fromPartial(base ?? {});
+  create(base?: DeepPartial<GraphProjectionDefinition_EdgesEntry>): GraphProjectionDefinition_EdgesEntry {
+    return GraphProjectionDefinition_EdgesEntry.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<GetAllDefinitionsRequest>): GetAllDefinitionsRequest {
-    const message = createBaseGetAllDefinitionsRequest();
-    message.EventStore = object.EventStore ?? "";
+  fromPartial(object: DeepPartial<GraphProjectionDefinition_EdgesEntry>): GraphProjectionDefinition_EdgesEntry {
+    const message = createBaseGraphProjectionDefinition_EdgesEntry();
+    message.key = object.key ?? "";
+    message.value = (object.value !== undefined && object.value !== null)
+      ? GraphEdgeProjectionDefinition.fromPartial(object.value)
+      : undefined;
     return message;
   },
 };
@@ -3431,6 +5136,7 @@ function createBaseProjectionDefinition(): ProjectionDefinition {
     SubscribesToAllEvents: false,
     NoAutoMapProperties: [],
     GenerationDelivery: 0,
+    Graph: undefined,
   };
 }
 
@@ -3499,6 +5205,9 @@ export const ProjectionDefinition: MessageFns<ProjectionDefinition> = {
     if (message.GenerationDelivery !== 0) {
       writer.uint32(168).int32(message.GenerationDelivery);
     }
+    if (message.Graph !== undefined) {
+      GraphProjectionDefinition.encode(message.Graph, writer.uint32(178).fork()).join();
+    }
     return writer;
   },
 
@@ -3691,6 +5400,14 @@ export const ProjectionDefinition: MessageFns<ProjectionDefinition> = {
             message.GenerationDelivery = reader.int32() as any;
             continue;
           }
+          case 22: {
+            if (tag !== 178) {
+              break;
+            }
+
+            message.Graph = GraphProjectionDefinition.decode(reader, reader.uint32());
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -3770,6 +5487,7 @@ export const ProjectionDefinition: MessageFns<ProjectionDefinition> = {
       GenerationDelivery: isSet(object.GenerationDelivery)
         ? eventGenerationDeliveryFromJSON(object.GenerationDelivery)
         : 0,
+      Graph: isSet(object.Graph) ? GraphProjectionDefinition.fromJSON(object.Graph) : undefined,
     };
   },
 
@@ -3852,6 +5570,9 @@ export const ProjectionDefinition: MessageFns<ProjectionDefinition> = {
     if (message.GenerationDelivery !== 0) {
       obj.GenerationDelivery = eventGenerationDeliveryToJSON(message.GenerationDelivery);
     }
+    if (message.Graph !== undefined) {
+      obj.Graph = GraphProjectionDefinition.toJSON(message.Graph);
+    }
     return obj;
   },
 
@@ -3905,6 +5626,9 @@ export const ProjectionDefinition: MessageFns<ProjectionDefinition> = {
     message.SubscribesToAllEvents = object.SubscribesToAllEvents ?? false;
     message.NoAutoMapProperties = object.NoAutoMapProperties?.map((e) => e) || [];
     message.GenerationDelivery = object.GenerationDelivery ?? 0;
+    message.Graph = (object.Graph !== undefined && object.Graph !== null)
+      ? GraphProjectionDefinition.fromPartial(object.Graph)
+      : undefined;
     return message;
   },
 };