@pagopa/interop-outbound-models 1.0.0

package/dist/agreement/index.d.ts

@@ -0,0 +1,228 @@
+import { z } from "zod";
+import { AgreementEventV1 } from "./eventsV1.js";
+import { AgreementEventV2 } from "./eventsV2.js";
+export declare function encodeOutboundAgreementEvent(event: AgreementEvent): string;
+export declare function decodeOutboundAgreementEvent(encodedEvent: string): AgreementEvent;
+export declare const AgreementEvent: z.ZodEffects<z.ZodDiscriminatedUnion<"event_version", [z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    event_version: z.ZodLiteral<1>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    event_version: z.ZodLiteral<1>;
+}, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    event_version: z.ZodLiteral<2>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    event_version: z.ZodLiteral<2>;
+}, z.ZodTypeAny, "passthrough">>]>, {
+    event_version: 1;
+    type: "AgreementAdded";
+    version: number;
+    data: import("../index.js").AgreementAddedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "AgreementActivated";
+    version: number;
+    data: import("../index.js").AgreementActivatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "AgreementSuspended";
+    version: number;
+    data: import("../index.js").AgreementSuspendedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "AgreementDeactivated";
+    version: number;
+    data: import("../index.js").AgreementDeactivatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "AgreementDeleted";
+    version: number;
+    data: import("../index.js").AgreementDeletedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "VerifiedAttributeUpdated";
+    version: number;
+    data: import("../index.js").VerifiedAttributeUpdatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "AgreementUpdated";
+    version: number;
+    data: import("../index.js").AgreementUpdatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "AgreementConsumerDocumentAdded";
+    version: number;
+    data: import("../index.js").AgreementConsumerDocumentAddedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "AgreementConsumerDocumentRemoved";
+    version: number;
+    data: import("../index.js").AgreementConsumerDocumentRemovedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "AgreementContractAdded";
+    version: number;
+    data: import("../index.js").AgreementContractAddedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementAdded";
+    version: number;
+    data: import("../index.js").AgreementAddedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementDeleted";
+    version: number;
+    data: import("../index.js").AgreementDeletedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "DraftAgreementUpdated";
+    version: number;
+    data: import("../index.js").DraftAgreementUpdatedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementSubmitted";
+    version: number;
+    data: import("../index.js").AgreementSubmittedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementActivated";
+    version: number;
+    data: import("../index.js").AgreementActivatedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementUnsuspendedByProducer";
+    version: number;
+    data: import("../index.js").AgreementUnsuspendedByProducerV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementUnsuspendedByConsumer";
+    version: number;
+    data: import("../index.js").AgreementUnsuspendedByConsumerV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementUnsuspendedByPlatform";
+    version: number;
+    data: import("../index.js").AgreementUnsuspendedByPlatformV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementArchivedByConsumer";
+    version: number;
+    data: import("../index.js").AgreementArchivedByConsumerV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementArchivedByUpgrade";
+    version: number;
+    data: import("../index.js").AgreementArchivedByUpgradeV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementUpgraded";
+    version: number;
+    data: import("../index.js").AgreementUpgradedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementSuspendedByProducer";
+    version: number;
+    data: import("../index.js").AgreementSuspendedByProducerV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementSuspendedByConsumer";
+    version: number;
+    data: import("../index.js").AgreementSuspendedByConsumerV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementSuspendedByPlatform";
+    version: number;
+    data: import("../index.js").AgreementSuspendedByPlatformV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementRejected";
+    version: number;
+    data: import("../index.js").AgreementRejectedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementConsumerDocumentAdded";
+    version: number;
+    data: import("../index.js").AgreementConsumerDocumentAddedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementConsumerDocumentRemoved";
+    version: number;
+    data: import("../index.js").AgreementConsumerDocumentRemovedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementSetDraftByPlatform";
+    version: number;
+    data: import("../index.js").AgreementSetDraftByPlatformV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "AgreementSetMissingCertifiedAttributesByPlatform";
+    version: number;
+    data: import("../index.js").AgreementSetMissingCertifiedAttributesByPlatformV2;
+    stream_id: string;
+    timestamp: Date;
+}, z.objectInputType<{
+    event_version: z.ZodLiteral<1>;
+}, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+    event_version: z.ZodLiteral<2>;
+}, z.ZodTypeAny, "passthrough">>;
+export type AgreementEvent = z.infer<typeof AgreementEvent>;
+export { AgreementEventV1, AgreementEventV2 };
+//# sourceMappingURL=index.d.ts.map

package/dist/agreement/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agreement/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,gBAAgB,EAAgC,MAAM,eAAe,CAAC;AAC/E,OAAO,EAAE,gBAAgB,EAAgC,MAAM,eAAe,CAAC;AAS/E,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAS1E;AAED,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,MAAM,GACnB,cAAc,CAEhB;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAWzB,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/agreement/index.js

@@ -0,0 +1,36 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { VersionedEvent } from "../utils.js";
+import { AgreementEventV1, agreementEventToBinaryDataV1 } from "./eventsV1.js";
+import { AgreementEventV2, agreementEventToBinaryDataV2 } from "./eventsV2.js";
+function agreementEventToBinaryData(event) {
+    return match(event)
+        .with({ event_version: 1 }, agreementEventToBinaryDataV1)
+        .with({ event_version: 2 }, agreementEventToBinaryDataV2)
+        .exhaustive();
+}
+export function encodeOutboundAgreementEvent(event) {
+    return JSON.stringify({
+        event_version: event.event_version,
+        type: event.type,
+        data: agreementEventToBinaryData(event),
+        stream_id: event.stream_id,
+        version: event.version,
+        timestamp: event.timestamp,
+    });
+}
+export function decodeOutboundAgreementEvent(encodedEvent) {
+    return AgreementEvent.parse(JSON.parse(encodedEvent));
+}
+export const AgreementEvent = VersionedEvent.transform((obj, ctx) => {
+    const res = match(obj)
+        .with({ event_version: 1 }, () => AgreementEventV1.safeParse(obj))
+        .with({ event_version: 2 }, () => AgreementEventV2.safeParse(obj))
+        .exhaustive();
+    if (!res.success) {
+        res.error.issues.forEach(ctx.addIssue);
+        return z.NEVER;
+    }
+    return res.data;
+});
+export { AgreementEventV1, AgreementEventV2 };

package/dist/eservice/eventsV1.d.ts

@@ -0,0 +1,237 @@
+import { z } from "zod";
+import { ClonedEServiceAddedV1, EServiceAddedV1, EServiceDeletedV1, EServiceDescriptorAddedV1, EServiceDescriptorUpdatedV1, EServiceDocumentAddedV1, EServiceDocumentDeletedV1, EServiceDocumentUpdatedV1, EServiceUpdatedV1, EServiceWithDescriptorsDeletedV1, MovedAttributesFromEserviceToDescriptorsV1 } from "../gen/v1/eservice/events.js";
+export declare function eServiceEventToBinaryDataV1(event: EServiceEventV1): Uint8Array;
+export declare const EServiceEventV1: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"EServiceAdded">;
+    data: z.ZodEffects<z.ZodAny, EServiceAddedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "EServiceAdded";
+    version: number;
+    data: EServiceAddedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "EServiceAdded";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"ClonedEServiceAdded">;
+    data: z.ZodEffects<z.ZodAny, ClonedEServiceAddedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "ClonedEServiceAdded";
+    version: number;
+    data: ClonedEServiceAddedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "ClonedEServiceAdded";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"EServiceUpdated">;
+    data: z.ZodEffects<z.ZodAny, EServiceUpdatedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "EServiceUpdated";
+    version: number;
+    data: EServiceUpdatedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "EServiceUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"EServiceWithDescriptorsDeleted">;
+    data: z.ZodEffects<z.ZodAny, EServiceWithDescriptorsDeletedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "EServiceWithDescriptorsDeleted";
+    version: number;
+    data: EServiceWithDescriptorsDeletedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "EServiceWithDescriptorsDeleted";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"EServiceDocumentUpdated">;
+    data: z.ZodEffects<z.ZodAny, EServiceDocumentUpdatedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "EServiceDocumentUpdated";
+    version: number;
+    data: EServiceDocumentUpdatedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "EServiceDocumentUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"EServiceDeleted">;
+    data: z.ZodEffects<z.ZodAny, EServiceDeletedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "EServiceDeleted";
+    version: number;
+    data: EServiceDeletedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "EServiceDeleted";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"EServiceDocumentAdded">;
+    data: z.ZodEffects<z.ZodAny, EServiceDocumentAddedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "EServiceDocumentAdded";
+    version: number;
+    data: EServiceDocumentAddedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "EServiceDocumentAdded";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"EServiceDocumentDeleted">;
+    data: z.ZodEffects<z.ZodAny, EServiceDocumentDeletedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "EServiceDocumentDeleted";
+    version: number;
+    data: EServiceDocumentDeletedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "EServiceDocumentDeleted";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"EServiceDescriptorAdded">;
+    data: z.ZodEffects<z.ZodAny, EServiceDescriptorAddedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "EServiceDescriptorAdded";
+    version: number;
+    data: EServiceDescriptorAddedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "EServiceDescriptorAdded";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"EServiceDescriptorUpdated">;
+    data: z.ZodEffects<z.ZodAny, EServiceDescriptorUpdatedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "EServiceDescriptorUpdated";
+    version: number;
+    data: EServiceDescriptorUpdatedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "EServiceDescriptorUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"MovedAttributesFromEserviceToDescriptors">;
+    data: z.ZodEffects<z.ZodAny, MovedAttributesFromEserviceToDescriptorsV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "MovedAttributesFromEserviceToDescriptors";
+    version: number;
+    data: MovedAttributesFromEserviceToDescriptorsV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "MovedAttributesFromEserviceToDescriptors";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>]>;
+export type EServiceEventV1 = z.infer<typeof EServiceEventV1>;
+//# sourceMappingURL=eventsV1.d.ts.map

package/dist/eservice/eventsV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventsV1.d.ts","sourceRoot":"","sources":["../../src/eservice/eventsV1.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,yBAAyB,EACzB,2BAA2B,EAC3B,uBAAuB,EACvB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,gCAAgC,EAChC,0CAA0C,EAC3C,MAAM,8BAA8B,CAAC;AAGtC,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,eAAe,GACrB,UAAU,CAoCZ;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyF1B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/eservice/eventsV1.js

@@ -0,0 +1,109 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { ClonedEServiceAddedV1, EServiceAddedV1, EServiceDeletedV1, EServiceDescriptorAddedV1, EServiceDescriptorUpdatedV1, EServiceDocumentAddedV1, EServiceDocumentDeletedV1, EServiceDocumentUpdatedV1, EServiceUpdatedV1, EServiceWithDescriptorsDeletedV1, MovedAttributesFromEserviceToDescriptorsV1, } from "../gen/v1/eservice/events.js";
+import { protobufDecoder } from "../utils.js";
+export function eServiceEventToBinaryDataV1(event) {
+    return match(event)
+        .with({ type: "EServiceAdded" }, ({ data }) => EServiceAddedV1.toBinary(data))
+        .with({ type: "ClonedEServiceAdded" }, ({ data }) => ClonedEServiceAddedV1.toBinary(data))
+        .with({ type: "EServiceUpdated" }, ({ data }) => EServiceUpdatedV1.toBinary(data))
+        .with({ type: "EServiceWithDescriptorsDeleted" }, ({ data }) => EServiceWithDescriptorsDeletedV1.toBinary(data))
+        .with({ type: "EServiceDocumentUpdated" }, ({ data }) => EServiceDocumentUpdatedV1.toBinary(data))
+        .with({ type: "EServiceDeleted" }, ({ data }) => EServiceDeletedV1.toBinary(data))
+        .with({ type: "EServiceDocumentAdded" }, ({ data }) => EServiceDocumentAddedV1.toBinary(data))
+        .with({ type: "EServiceDocumentDeleted" }, ({ data }) => EServiceDocumentDeletedV1.toBinary(data))
+        .with({ type: "EServiceDescriptorAdded" }, ({ data }) => EServiceDescriptorAddedV1.toBinary(data))
+        .with({ type: "EServiceDescriptorUpdated" }, ({ data }) => EServiceDescriptorUpdatedV1.toBinary(data))
+        .with({ type: "MovedAttributesFromEserviceToDescriptors" }, ({ data }) => MovedAttributesFromEserviceToDescriptorsV1.toBinary(data))
+        .exhaustive();
+}
+export const EServiceEventV1 = z.discriminatedUnion("type", [
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("EServiceAdded"),
+        data: protobufDecoder(EServiceAddedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("ClonedEServiceAdded"),
+        data: protobufDecoder(ClonedEServiceAddedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("EServiceUpdated"),
+        data: protobufDecoder(EServiceUpdatedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("EServiceWithDescriptorsDeleted"),
+        data: protobufDecoder(EServiceWithDescriptorsDeletedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("EServiceDocumentUpdated"),
+        data: protobufDecoder(EServiceDocumentUpdatedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("EServiceDeleted"),
+        data: protobufDecoder(EServiceDeletedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("EServiceDocumentAdded"),
+        data: protobufDecoder(EServiceDocumentAddedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("EServiceDocumentDeleted"),
+        data: protobufDecoder(EServiceDocumentDeletedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("EServiceDescriptorAdded"),
+        data: protobufDecoder(EServiceDescriptorAddedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("EServiceDescriptorUpdated"),
+        data: protobufDecoder(EServiceDescriptorUpdatedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("MovedAttributesFromEserviceToDescriptors"),
+        data: protobufDecoder(MovedAttributesFromEserviceToDescriptorsV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+]);