@cratis/chronicle.contracts 19.128.1 → 19.129.0

package/dist/cjs/generated/projections.js

@@ -1668,6 +1668,1444 @@ const GetAllDefinitionsRequest = {
         return message;
     },
 };
+function createBaseGraphEdgeFromDefinition() {
+    return { SourceKey: "", TargetKey: "", Identity: "", Properties: {} };
+}
+const GraphEdgeFromDefinition = {
+    encode(message, writer = new wire.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]) => {
+            GraphEdgeFromDefinition_PropertiesEntry.encode({ key: key, value }, writer.uint32(34).fork()).join();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        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).reduce((acc, [key, value]) => {
+                    globalThis.Object.defineProperty(acc, key, {
+                        value: globalThis.String(value),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                    });
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        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);
+            if (entries.length > 0) {
+                obj.Properties = {};
+                entries.forEach(([k, v]) => {
+                    obj.Properties[k] = v;
+                });
+            }
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphEdgeFromDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphEdgeFromDefinition();
+        message.SourceKey = object.SourceKey ?? "";
+        message.TargetKey = object.TargetKey ?? "";
+        message.Identity = object.Identity ?? "";
+        message.Properties = globalThis.Object.entries(object.Properties ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = globalThis.String(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseGraphEdgeFromDefinition_PropertiesEntry() {
+    return { key: "", value: "" };
+}
+const GraphEdgeFromDefinition_PropertiesEntry = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? globalThis.String(object.value) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== "") {
+            obj.value = message.value;
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphEdgeFromDefinition_PropertiesEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphEdgeFromDefinition_PropertiesEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+};
+function createBaseGraphEdgeProjectionDefinition() {
+    return { From: {}, RemovedWith: {} };
+}
+const GraphEdgeProjectionDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        globalThis.Object.entries(message.From).forEach(([key, value]) => {
+            GraphEdgeProjectionDefinition_FromEntry.encode({ key: key, value }, writer.uint32(10).fork()).join();
+        });
+        globalThis.Object.entries(message.RemovedWith).forEach(([key, value]) => {
+            GraphEdgeProjectionDefinition_RemovedWithEntry.encode({ key: key, value }, writer.uint32(18).fork())
+                .join();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            From: isObject(object.From)
+                ? globalThis.Object.entries(object.From).reduce((acc, [key, value]) => {
+                    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).reduce((acc, [key, value]) => {
+                    globalThis.Object.defineProperty(acc, key, {
+                        value: GraphEdgeRemovedWithDefinition.fromJSON(value),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                    });
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.From) {
+            const entries = globalThis.Object.entries(message.From);
+            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);
+            if (entries.length > 0) {
+                obj.RemovedWith = {};
+                entries.forEach(([k, v]) => {
+                    obj.RemovedWith[k] = GraphEdgeRemovedWithDefinition.toJSON(v);
+                });
+            }
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphEdgeProjectionDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphEdgeProjectionDefinition();
+        message.From = globalThis.Object.entries(object.From ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = GraphEdgeFromDefinition.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.RemovedWith =
+            globalThis.Object.entries(object.RemovedWith ?? {}).reduce((acc, [key, value]) => {
+                if (value !== undefined) {
+                    acc[key] = GraphEdgeRemovedWithDefinition.fromPartial(value);
+                }
+                return acc;
+            }, {});
+        return message;
+    },
+};
+function createBaseGraphEdgeProjectionDefinition_FromEntry() {
+    return { key: "", value: undefined };
+}
+const GraphEdgeProjectionDefinition_FromEntry = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? GraphEdgeFromDefinition.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = GraphEdgeFromDefinition.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphEdgeProjectionDefinition_FromEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        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() {
+    return { key: "", value: undefined };
+}
+const GraphEdgeProjectionDefinition_RemovedWithEntry = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? GraphEdgeRemovedWithDefinition.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = GraphEdgeRemovedWithDefinition.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphEdgeProjectionDefinition_RemovedWithEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        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() {
+    return { SourceKey: "", TargetKey: "", Identity: "" };
+}
+const GraphEdgeRemovedWithDefinition = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        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) {
+        const obj = {};
+        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) {
+        return GraphEdgeRemovedWithDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphEdgeRemovedWithDefinition();
+        message.SourceKey = object.SourceKey ?? "";
+        message.TargetKey = object.TargetKey ?? "";
+        message.Identity = object.Identity ?? "";
+        return message;
+    },
+};
+function createBaseGraphNodeFromDefinition() {
+    return { Key: "", Properties: {}, UpdateOnly: false };
+}
+const GraphNodeFromDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Key !== "") {
+            writer.uint32(10).string(message.Key);
+        }
+        globalThis.Object.entries(message.Properties).forEach(([key, value]) => {
+            GraphNodeFromDefinition_PropertiesEntry.encode({ key: key, value }, writer.uint32(18).fork()).join();
+        });
+        if (message.UpdateOnly !== false) {
+            writer.uint32(24).bool(message.UpdateOnly);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Key: isSet(object.Key) ? globalThis.String(object.Key) : "",
+            Properties: isObject(object.Properties)
+                ? globalThis.Object.entries(object.Properties).reduce((acc, [key, value]) => {
+                    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) {
+        const obj = {};
+        if (message.Key !== "") {
+            obj.Key = message.Key;
+        }
+        if (message.Properties) {
+            const entries = globalThis.Object.entries(message.Properties);
+            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) {
+        return GraphNodeFromDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphNodeFromDefinition();
+        message.Key = object.Key ?? "";
+        message.Properties = globalThis.Object.entries(object.Properties ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = globalThis.String(value);
+            }
+            return acc;
+        }, {});
+        message.UpdateOnly = object.UpdateOnly ?? false;
+        return message;
+    },
+};
+function createBaseGraphNodeFromDefinition_PropertiesEntry() {
+    return { key: "", value: "" };
+}
+const GraphNodeFromDefinition_PropertiesEntry = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? globalThis.String(object.value) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== "") {
+            obj.value = message.value;
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphNodeFromDefinition_PropertiesEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphNodeFromDefinition_PropertiesEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+};
+function createBaseGraphNodeProjectionDefinition() {
+    return { From: {}, RemovedWith: {} };
+}
+const GraphNodeProjectionDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        globalThis.Object.entries(message.From).forEach(([key, value]) => {
+            GraphNodeProjectionDefinition_FromEntry.encode({ key: key, value }, writer.uint32(10).fork()).join();
+        });
+        globalThis.Object.entries(message.RemovedWith).forEach(([key, value]) => {
+            GraphNodeProjectionDefinition_RemovedWithEntry.encode({ key: key, value }, writer.uint32(18).fork())
+                .join();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            From: isObject(object.From)
+                ? globalThis.Object.entries(object.From).reduce((acc, [key, value]) => {
+                    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).reduce((acc, [key, value]) => {
+                    globalThis.Object.defineProperty(acc, key, {
+                        value: GraphNodeRemovedWithDefinition.fromJSON(value),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                    });
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.From) {
+            const entries = globalThis.Object.entries(message.From);
+            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);
+            if (entries.length > 0) {
+                obj.RemovedWith = {};
+                entries.forEach(([k, v]) => {
+                    obj.RemovedWith[k] = GraphNodeRemovedWithDefinition.toJSON(v);
+                });
+            }
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphNodeProjectionDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphNodeProjectionDefinition();
+        message.From = globalThis.Object.entries(object.From ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = GraphNodeFromDefinition.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.RemovedWith =
+            globalThis.Object.entries(object.RemovedWith ?? {}).reduce((acc, [key, value]) => {
+                if (value !== undefined) {
+                    acc[key] = GraphNodeRemovedWithDefinition.fromPartial(value);
+                }
+                return acc;
+            }, {});
+        return message;
+    },
+};
+function createBaseGraphNodeProjectionDefinition_FromEntry() {
+    return { key: "", value: undefined };
+}
+const GraphNodeProjectionDefinition_FromEntry = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? GraphNodeFromDefinition.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = GraphNodeFromDefinition.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphNodeProjectionDefinition_FromEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        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() {
+    return { key: "", value: undefined };
+}
+const GraphNodeProjectionDefinition_RemovedWithEntry = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__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.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? GraphNodeRemovedWithDefinition.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = GraphNodeRemovedWithDefinition.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphNodeProjectionDefinition_RemovedWithEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        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() {
+    return { Key: "", Detach: false };
+}
+const GraphNodeRemovedWithDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Key !== "") {
+            writer.uint32(10).string(message.Key);
+        }
+        if (message.Detach !== false) {
+            writer.uint32(16).bool(message.Detach);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseGraphNodeRemovedWithDefinition();
+            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 !== 16) {
+                            break;
+                        }
+                        message.Detach = reader.bool();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Key: isSet(object.Key) ? globalThis.String(object.Key) : "",
+            Detach: isSet(object.Detach) ? globalThis.Boolean(object.Detach) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Key !== "") {
+            obj.Key = message.Key;
+        }
+        if (message.Detach !== false) {
+            obj.Detach = message.Detach;
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphNodeRemovedWithDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphNodeRemovedWithDefinition();
+        message.Key = object.Key ?? "";
+        message.Detach = object.Detach ?? false;
+        return message;
+    },
+};
+function createBaseGraphProjectionDefinition() {
+    return { Nodes: {}, Edges: {} };
+}
+const GraphProjectionDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        globalThis.Object.entries(message.Nodes).forEach(([key, value]) => {
+            GraphProjectionDefinition_NodesEntry.encode({ key: key, value }, writer.uint32(10).fork()).join();
+        });
+        globalThis.Object.entries(message.Edges).forEach(([key, value]) => {
+            GraphProjectionDefinition_EdgesEntry.encode({ key: key, value }, writer.uint32(18).fork()).join();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseGraphProjectionDefinition();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        const entry1 = GraphProjectionDefinition_NodesEntry.decode(reader, reader.uint32());
+                        if (entry1.value !== undefined) {
+                            message.Nodes[entry1.key] = entry1.value;
+                        }
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        const entry2 = GraphProjectionDefinition_EdgesEntry.decode(reader, reader.uint32());
+                        if (entry2.value !== undefined) {
+                            message.Edges[entry2.key] = entry2.value;
+                        }
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Nodes: isObject(object.Nodes)
+                ? globalThis.Object.entries(object.Nodes).reduce((acc, [key, value]) => {
+                    globalThis.Object.defineProperty(acc, key, {
+                        value: GraphNodeProjectionDefinition.fromJSON(value),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                    });
+                    return acc;
+                }, {})
+                : {},
+            Edges: isObject(object.Edges)
+                ? globalThis.Object.entries(object.Edges).reduce((acc, [key, value]) => {
+                    globalThis.Object.defineProperty(acc, key, {
+                        value: GraphEdgeProjectionDefinition.fromJSON(value),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                    });
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Nodes) {
+            const entries = globalThis.Object.entries(message.Nodes);
+            if (entries.length > 0) {
+                obj.Nodes = {};
+                entries.forEach(([k, v]) => {
+                    obj.Nodes[k] = GraphNodeProjectionDefinition.toJSON(v);
+                });
+            }
+        }
+        if (message.Edges) {
+            const entries = globalThis.Object.entries(message.Edges);
+            if (entries.length > 0) {
+                obj.Edges = {};
+                entries.forEach(([k, v]) => {
+                    obj.Edges[k] = GraphEdgeProjectionDefinition.toJSON(v);
+                });
+            }
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphProjectionDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphProjectionDefinition();
+        message.Nodes = globalThis.Object.entries(object.Nodes ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = GraphNodeProjectionDefinition.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.Edges = globalThis.Object.entries(object.Edges ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = GraphEdgeProjectionDefinition.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseGraphProjectionDefinition_NodesEntry() {
+    return { key: "", value: undefined };
+}
+const GraphProjectionDefinition_NodesEntry = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            GraphNodeProjectionDefinition.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseGraphProjectionDefinition_NodesEntry();
+            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 = GraphNodeProjectionDefinition.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? GraphNodeProjectionDefinition.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = GraphNodeProjectionDefinition.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphProjectionDefinition_NodesEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphProjectionDefinition_NodesEntry();
+        message.key = object.key ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? GraphNodeProjectionDefinition.fromPartial(object.value)
+            : undefined;
+        return message;
+    },
+};
+function createBaseGraphProjectionDefinition_EdgesEntry() {
+    return { key: "", value: undefined };
+}
+const GraphProjectionDefinition_EdgesEntry = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseGraphProjectionDefinition_EdgesEntry();
+            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 = GraphEdgeProjectionDefinition.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? GraphEdgeProjectionDefinition.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = GraphEdgeProjectionDefinition.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return GraphProjectionDefinition_EdgesEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGraphProjectionDefinition_EdgesEntry();
+        message.key = object.key ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? GraphEdgeProjectionDefinition.fromPartial(object.value)
+            : undefined;
+        return message;
+    },
+};
 function createBaseIEnumerableProjectionDefinition() {
     return { items: [] };
 }
@@ -2876,6 +4314,7 @@ function createBaseProjectionDefinition() {
         SubscribesToAllEvents: false,
         NoAutoMapProperties: [],
         GenerationDelivery: 0,
+        Graph: undefined,
     };
 }
 const ProjectionDefinition = {
@@ -2943,6 +4382,9 @@ const 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;
     },
     decode(input, length) {
@@ -3111,6 +4553,13 @@ const ProjectionDefinition = {
                         message.GenerationDelivery = reader.int32();
                         continue;
                     }
+                    case 22: {
+                        if (tag !== 178) {
+                            break;
+                        }
+                        message.Graph = GraphProjectionDefinition.decode(reader, reader.uint32());
+                        continue;
+                    }
                 }
                 if ((tag & 7) === 4 || tag === 0) {
                     break;
@@ -3184,6 +4633,7 @@ const ProjectionDefinition = {
             GenerationDelivery: isSet(object.GenerationDelivery)
                 ? eventGenerationDeliveryFromJSON(object.GenerationDelivery)
                 : 0,
+            Graph: isSet(object.Graph) ? GraphProjectionDefinition.fromJSON(object.Graph) : undefined,
         };
     },
     toJSON(message) {
@@ -3263,6 +4713,9 @@ const ProjectionDefinition = {
         if (message.GenerationDelivery !== 0) {
             obj.GenerationDelivery = eventGenerationDeliveryToJSON(message.GenerationDelivery);
         }
+        if (message.Graph !== undefined) {
+            obj.Graph = GraphProjectionDefinition.toJSON(message.Graph);
+        }
         return obj;
     },
     create(base) {
@@ -3309,6 +4762,9 @@ const 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;
     },
 };
@@ -4677,6 +6133,21 @@ exports.FromEveryDefinition = FromEveryDefinition;
 exports.FromEveryDefinition_PropertiesEntry = FromEveryDefinition_PropertiesEntry;
 exports.GetAllDeclarationsRequest = GetAllDeclarationsRequest;
 exports.GetAllDefinitionsRequest = GetAllDefinitionsRequest;
+exports.GraphEdgeFromDefinition = GraphEdgeFromDefinition;
+exports.GraphEdgeFromDefinition_PropertiesEntry = GraphEdgeFromDefinition_PropertiesEntry;
+exports.GraphEdgeProjectionDefinition = GraphEdgeProjectionDefinition;
+exports.GraphEdgeProjectionDefinition_FromEntry = GraphEdgeProjectionDefinition_FromEntry;
+exports.GraphEdgeProjectionDefinition_RemovedWithEntry = GraphEdgeProjectionDefinition_RemovedWithEntry;
+exports.GraphEdgeRemovedWithDefinition = GraphEdgeRemovedWithDefinition;
+exports.GraphNodeFromDefinition = GraphNodeFromDefinition;
+exports.GraphNodeFromDefinition_PropertiesEntry = GraphNodeFromDefinition_PropertiesEntry;
+exports.GraphNodeProjectionDefinition = GraphNodeProjectionDefinition;
+exports.GraphNodeProjectionDefinition_FromEntry = GraphNodeProjectionDefinition_FromEntry;
+exports.GraphNodeProjectionDefinition_RemovedWithEntry = GraphNodeProjectionDefinition_RemovedWithEntry;
+exports.GraphNodeRemovedWithDefinition = GraphNodeRemovedWithDefinition;
+exports.GraphProjectionDefinition = GraphProjectionDefinition;
+exports.GraphProjectionDefinition_EdgesEntry = GraphProjectionDefinition_EdgesEntry;
+exports.GraphProjectionDefinition_NodesEntry = GraphProjectionDefinition_NodesEntry;
 exports.IEnumerableProjectionDefinition = IEnumerableProjectionDefinition;
 exports.IEnumerableProjectionWithDeclaration = IEnumerableProjectionWithDeclaration;
 exports.IndexDefinition = IndexDefinition;