@pagopa/interop-outbound-models 1.0.0

package/dist/tenant/eventsV2.js

@@ -0,0 +1,118 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { TenantOnboardedV2, TenantOnboardDetailsUpdatedV2, TenantCertifiedAttributeAssignedV2, TenantCertifiedAttributeRevokedV2, TenantDeclaredAttributeAssignedV2, TenantDeclaredAttributeRevokedV2, TenantVerifiedAttributeAssignedV2, TenantVerifiedAttributeRevokedV2, TenantVerifiedAttributeExpirationUpdatedV2, MaintenanceTenantDeletedV2, TenantVerifiedAttributeExtensionUpdatedV2, TenantKindUpdatedV2, } from "../gen/v2/tenant/events.js";
+import { protobufDecoder } from "../utils.js";
+export function tenantEventToBinaryDataV2(event) {
+    return match(event)
+        .with({ type: "TenantOnboarded" }, ({ data }) => TenantOnboardedV2.toBinary(data))
+        .with({ type: "TenantOnboardDetailsUpdated" }, ({ data }) => TenantOnboardDetailsUpdatedV2.toBinary(data))
+        .with({ type: "TenantCertifiedAttributeAssigned" }, ({ data }) => TenantCertifiedAttributeAssignedV2.toBinary(data))
+        .with({ type: "TenantCertifiedAttributeRevoked" }, ({ data }) => TenantCertifiedAttributeRevokedV2.toBinary(data))
+        .with({ type: "TenantDeclaredAttributeAssigned" }, ({ data }) => TenantDeclaredAttributeAssignedV2.toBinary(data))
+        .with({ type: "TenantDeclaredAttributeRevoked" }, ({ data }) => TenantDeclaredAttributeRevokedV2.toBinary(data))
+        .with({ type: "TenantVerifiedAttributeAssigned" }, ({ data }) => TenantVerifiedAttributeAssignedV2.toBinary(data))
+        .with({ type: "TenantVerifiedAttributeRevoked" }, ({ data }) => TenantVerifiedAttributeRevokedV2.toBinary(data))
+        .with({ type: "TenantVerifiedAttributeExpirationUpdated" }, ({ data }) => TenantVerifiedAttributeExpirationUpdatedV2.toBinary(data))
+        .with({ type: "TenantVerifiedAttributeExtensionUpdated" }, ({ data }) => TenantVerifiedAttributeExtensionUpdatedV2.toBinary(data))
+        .with({ type: "MaintenanceTenantDeleted" }, ({ data }) => MaintenanceTenantDeletedV2.toBinary(data))
+        .with({ type: "TenantKindUpdated" }, ({ data }) => TenantKindUpdatedV2.toBinary(data))
+        .exhaustive();
+}
+export const TenantEventV2 = z.discriminatedUnion("type", [
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantOnboarded"),
+        data: protobufDecoder(TenantOnboardedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantOnboardDetailsUpdated"),
+        data: protobufDecoder(TenantOnboardDetailsUpdatedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantCertifiedAttributeAssigned"),
+        data: protobufDecoder(TenantCertifiedAttributeAssignedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantCertifiedAttributeRevoked"),
+        data: protobufDecoder(TenantCertifiedAttributeRevokedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantDeclaredAttributeAssigned"),
+        data: protobufDecoder(TenantDeclaredAttributeAssignedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantDeclaredAttributeRevoked"),
+        data: protobufDecoder(TenantDeclaredAttributeRevokedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantVerifiedAttributeAssigned"),
+        data: protobufDecoder(TenantVerifiedAttributeAssignedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantVerifiedAttributeRevoked"),
+        data: protobufDecoder(TenantVerifiedAttributeRevokedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantVerifiedAttributeExpirationUpdated"),
+        data: protobufDecoder(TenantVerifiedAttributeExpirationUpdatedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantVerifiedAttributeExtensionUpdated"),
+        data: protobufDecoder(TenantVerifiedAttributeExtensionUpdatedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("MaintenanceTenantDeleted"),
+        data: protobufDecoder(MaintenanceTenantDeletedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("TenantKindUpdated"),
+        data: protobufDecoder(TenantKindUpdatedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+]);

package/dist/tenant/index.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+import { TenantEventV1 } from "./eventsV1.js";
+import { TenantEventV2 } from "./eventsV2.js";
+export declare function encodeOutboundTenantEvent(event: TenantEvent): string;
+export declare function decodeOutboundTenantEvent(encodedEvent: string): TenantEvent;
+export declare const TenantEvent: 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: "TenantCreated";
+    version: number;
+    data: import("../index.js").TenantCreatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "TenantUpdated";
+    version: number;
+    data: import("../index.js").TenantUpdatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "TenantDeleted";
+    version: number;
+    data: import("../index.js").TenantDeletedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantOnboarded";
+    version: number;
+    data: import("../index.js").TenantOnboardedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantOnboardDetailsUpdated";
+    version: number;
+    data: import("../index.js").TenantOnboardDetailsUpdatedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantCertifiedAttributeAssigned";
+    version: number;
+    data: import("../index.js").TenantCertifiedAttributeAssignedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantCertifiedAttributeRevoked";
+    version: number;
+    data: import("../index.js").TenantCertifiedAttributeRevokedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantDeclaredAttributeAssigned";
+    version: number;
+    data: import("../index.js").TenantDeclaredAttributeAssignedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantDeclaredAttributeRevoked";
+    version: number;
+    data: import("../index.js").TenantDeclaredAttributeRevokedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantVerifiedAttributeAssigned";
+    version: number;
+    data: import("../index.js").TenantVerifiedAttributeAssignedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantVerifiedAttributeRevoked";
+    version: number;
+    data: import("../index.js").TenantVerifiedAttributeRevokedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantVerifiedAttributeExpirationUpdated";
+    version: number;
+    data: import("../index.js").TenantVerifiedAttributeExpirationUpdatedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantVerifiedAttributeExtensionUpdated";
+    version: number;
+    data: import("../index.js").TenantVerifiedAttributeExtensionUpdatedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "MaintenanceTenantDeleted";
+    version: number;
+    data: import("../index.js").MaintenanceTenantDeletedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "TenantKindUpdated";
+    version: number;
+    data: import("../index.js").TenantKindUpdatedV2;
+    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 TenantEvent = z.infer<typeof TenantEvent>;
+export { TenantEventV1, TenantEventV2 };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tenant/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,aAAa,EAA6B,MAAM,eAAe,CAAC;AACzE,OAAO,EAAE,aAAa,EAA6B,MAAM,eAAe,CAAC;AASzE,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CASpE;AAED,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,CAE3E;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAWtB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC"}

package/dist/tenant/index.js

@@ -0,0 +1,36 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { VersionedEvent } from "../utils.js";
+import { TenantEventV1, tenantEventToBinaryDataV1 } from "./eventsV1.js";
+import { TenantEventV2, tenantEventToBinaryDataV2 } from "./eventsV2.js";
+function tenantEventToBinaryData(event) {
+    return match(event)
+        .with({ event_version: 1 }, tenantEventToBinaryDataV1)
+        .with({ event_version: 2 }, tenantEventToBinaryDataV2)
+        .exhaustive();
+}
+export function encodeOutboundTenantEvent(event) {
+    return JSON.stringify({
+        event_version: event.event_version,
+        type: event.type,
+        data: tenantEventToBinaryData(event),
+        stream_id: event.stream_id,
+        version: event.version,
+        timestamp: event.timestamp,
+    });
+}
+export function decodeOutboundTenantEvent(encodedEvent) {
+    return TenantEvent.parse(JSON.parse(encodedEvent));
+}
+export const TenantEvent = VersionedEvent.transform((obj, ctx) => {
+    const res = match(obj)
+        .with({ event_version: 1 }, () => TenantEventV1.safeParse(obj))
+        .with({ event_version: 2 }, () => TenantEventV2.safeParse(obj))
+        .exhaustive();
+    if (!res.success) {
+        res.error.issues.forEach(ctx.addIssue);
+        return z.NEVER;
+    }
+    return res.data;
+});
+export { TenantEventV1, TenantEventV2 };

package/dist/utils.d.ts

@@ -0,0 +1,17 @@
+import { MessageType } from "@protobuf-ts/runtime";
+import { ZodAny, ZodTransformer, z } from "zod";
+export declare const VersionedEvent: 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">>]>;
+export declare function protobufDecoder<I extends object>(decoder: MessageType<I>): ZodTransformer<ZodAny, I>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAEhD,eAAO,MAAM,cAAc;;;;;;;;;;;;kCAWzB,CAAC;AAEH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9C,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GACtB,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,CAM3B"}

package/dist/utils.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export const VersionedEvent = z.discriminatedUnion("event_version", [
+    z
+        .object({
+        event_version: z.literal(1),
+    })
+        .passthrough(),
+    z
+        .object({
+        event_version: z.literal(2),
+    })
+        .passthrough(),
+]);
+export function protobufDecoder(decoder) {
+    return z
+        .any()
+        .transform((v) => decoder.fromBinary(Buffer.from(Object.values(v), "hex")));
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@pagopa/interop-outbound-models",
+  "version": "1.0.0",
+  "description": "PagoPA Interoperability outbound models",
+  "main": "dist",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "lint": "eslint . --ext .ts,.tsx",
+    "lint:autofix": "eslint . --ext .ts,.tsx --fix",
+    "format:check": "prettier --check src",
+    "format:write": "prettier --write src",
+    "build": "tsc",
+    "check": "tsc --project tsconfig.check.json",
+    "generate-protobuf": "mkdirp ./src/gen && npx protoc --ts_opt=eslint_disable --ts_out ./src/gen --proto_path ./proto ./proto/**/**/*.proto && tsc-esm-fix --src='src/gen/' --ext='.js'"
+  },
+  "keywords": [],
+  "author": "",
+  "repository": {
+    "url": "https://github.com/pagopa/interop-outbound-models"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "ts-pattern": "5.2.0",
+    "zod": "3.23.8",
+    "@protobuf-ts/runtime": "2.9.4"
+  },
+  "devDependencies": {
+    "eslint": "8.57.0",
+    "mkdirp": "3.0.1",
+    "prettier": "2.8.8",
+    "tsc-esm-fix": "2.20.27",
+    "typescript": "5.4.5",
+    "@types/node": "20.14.6",
+    "@protobuf-ts/protoc": "2.9.4",
+    "@protobuf-ts/plugin": "2.9.4",
+    "@tsconfig/node-lts": "20.1.3",
+    "@pagopa/eslint-config": "3.0.0",
+    "vitest": "^2.0.4"
+  },
+  "config": {
+    "protocVersion": "26.1"
+  },
+  "packageManager": "pnpm@8.15.8"
+}

package/proto/v1/agreement/agreement.proto

@@ -0,0 +1,70 @@
+syntax = "proto2";
+
+package agreement;
+
+message AgreementV1 {
+  required string id = 1;
+  required string eserviceId = 2;
+  required string descriptorId = 3;
+  required string producerId = 4;
+  required string consumerId = 5;
+  required AgreementStateV1 state = 6;
+  repeated VerifiedAttributeV1 verifiedAttributes = 7;
+  optional bool suspendedByConsumer = 8;
+  optional bool suspendedByProducer = 9;
+  required int64 createdAt = 10;
+  optional int64 updatedAt = 11;
+  optional bool suspendedByPlatform = 12;
+  repeated CertifiedAttributeV1 certifiedAttributes = 13;
+  repeated DeclaredAttributeV1 declaredAttributes = 14;
+  repeated AgreementDocumentV1 consumerDocuments = 15;
+  optional string consumerNotes = 16;
+  optional AgreementDocumentV1 contract = 17;
+  optional StampsV1 stamps = 18;
+  optional string rejectionReason = 19;
+  optional int64 suspendedAt = 20;
+}
+
+message VerifiedAttributeV1 {
+  required string id = 1;
+}
+
+message CertifiedAttributeV1 {
+  required string id = 1;
+}
+
+message DeclaredAttributeV1 {
+  required string id = 1;
+}
+
+message AgreementDocumentV1 {
+  required string id = 1;
+  required string name = 2;
+  required string prettyName = 3;
+  required string contentType = 4;
+  required int64 createdAt = 5;
+}
+
+enum AgreementStateV1 {
+  PENDING = 1;
+  ACTIVE = 2;
+  SUSPENDED = 3;
+  ARCHIVED = 4;
+  DRAFT = 5;
+  MISSING_CERTIFIED_ATTRIBUTES = 6;
+  REJECTED = 7;
+}
+
+message StampV1 {
+  required int64 when = 1;
+}
+
+message StampsV1 {
+  optional StampV1 submission = 1;
+  optional StampV1 activation = 2;
+  optional StampV1 rejection = 3;
+  optional StampV1 suspensionByProducer = 4;
+  optional StampV1 upgrade = 5;
+  optional StampV1 archiving = 6;
+  optional StampV1 suspensionByConsumer = 7;
+}

package/proto/v1/agreement/events.proto

@@ -0,0 +1,48 @@
+syntax = "proto2";
+
+package agreement;
+
+import "v1/agreement/agreement.proto";
+
+message AgreementAddedV1 {
+  required AgreementV1 agreement = 1;
+}
+
+message AgreementActivatedV1 {
+  required AgreementV1 agreement = 1;
+}
+
+message AgreementSuspendedV1 {
+  required AgreementV1 agreement = 1;
+}
+
+message AgreementDeactivatedV1 {
+  required AgreementV1 agreement = 1;
+}
+
+message AgreementUpdatedV1 {
+  required AgreementV1 agreement = 1;
+}
+
+message AgreementDeletedV1 {
+  required string agreementId = 1;
+}
+
+message VerifiedAttributeUpdatedV1 {
+  required AgreementV1 agreement = 1;
+}
+
+message AgreementConsumerDocumentAddedV1 {
+  required string agreementId = 1;
+  required AgreementDocumentV1 document = 2;
+}
+
+message AgreementConsumerDocumentRemovedV1 {
+  required string agreementId = 1;
+  required string documentId = 2;
+}
+
+message AgreementContractAddedV1 {
+  required string agreementId = 1;
+  required AgreementDocumentV1 contract = 2;
+}

package/proto/v1/eservice/eservice.proto

@@ -0,0 +1,84 @@
+syntax = "proto2";
+
+package eservice;
+
+message EServiceV1 {
+  required string id = 1;
+  required string producerId = 2;
+  required string name = 3;
+  required string description = 4;
+  required EServiceTechnologyV1 technology = 5;
+  optional EServiceAttributesV1 attributes = 6;
+  repeated EServiceDescriptorV1 descriptors = 7;
+  optional int64 createdAt = 8;
+  optional EServiceModeV1 mode = 9;
+}
+
+message EServiceAttributeValueV1 {
+  required string id = 1;
+  required bool explicitAttributeVerification = 2;
+}
+
+message EServiceAttributeV1 {
+  optional EServiceAttributeValueV1 single = 1;
+  repeated EServiceAttributeValueV1 group = 2;
+}
+
+message EServiceAttributesV1 {
+  repeated EServiceAttributeV1 certified = 1;
+  repeated EServiceAttributeV1 declared = 2;
+  repeated EServiceAttributeV1 verified = 3;
+}
+
+message EServiceDescriptorV1 {
+  required string id = 1;
+  required string version = 2;
+  optional string description = 3;
+  repeated EServiceDocumentV1 docs = 4;
+  required EServiceDescriptorStateV1 state = 5;
+  optional EServiceDocumentV1 interface = 6;
+  repeated string audience = 7;
+  required int32 voucherLifespan = 8;
+  required int32 dailyCallsPerConsumer = 9;
+  required int32 dailyCallsTotal = 10;
+  optional AgreementApprovalPolicyV1 agreementApprovalPolicy = 11;
+  optional int64 createdAt = 12;
+  optional int64 publishedAt = 13;
+  repeated string serverUrls = 14;
+  optional int64 suspendedAt = 15;
+  optional int64 deprecatedAt = 16;
+  optional int64 archivedAt = 17;
+  optional EServiceAttributesV1 attributes = 18;
+}
+
+message EServiceDocumentV1 {
+  required string id = 1;
+  required string name = 2;
+  required string contentType = 3;
+  required string checksum = 4;
+  required string uploadDate = 5;
+  required string prettyName = 6;
+}
+
+enum EServiceDescriptorStateV1 {
+  DRAFT = 1;
+  PUBLISHED = 2;
+  DEPRECATED = 3;
+  SUSPENDED = 4;
+  ARCHIVED = 5;
+}
+
+enum EServiceTechnologyV1 {
+  REST = 1;
+  SOAP = 2;
+}
+
+enum AgreementApprovalPolicyV1 {
+  AUTOMATIC = 1;
+  MANUAL = 2;
+}
+
+enum EServiceModeV1 {
+  RECEIVE = 1;
+  DELIVER = 2;
+}

package/proto/v1/eservice/events.proto

@@ -0,0 +1,63 @@
+syntax = "proto2";
+
+package eservice;
+
+import "v1/eservice/eservice.proto";
+
+message EServiceAddedV1 {
+  required EServiceV1 eservice = 1;
+}
+
+message ClonedEServiceAddedV1 {
+  required EServiceV1 eservice = 1;
+}
+
+message EServiceUpdatedV1 {
+  required EServiceV1 eservice = 1;
+}
+
+message EServiceWithDescriptorsDeletedV1 {
+  required EServiceV1 eservice = 1;
+  required string descriptorId = 2;
+}
+
+message EServiceDocumentUpdatedV1 {
+  required string eserviceId = 1;
+  required string descriptorId = 2;
+  required string documentId = 3;
+  required EServiceDocumentV1 updatedDocument = 4;
+  repeated string serverUrls = 5;
+}
+
+message EServiceDeletedV1 {
+  required string eserviceId = 1;
+}
+
+message EServiceDocumentAddedV1 {
+  required string eserviceId = 1;
+  required string descriptorId = 2;
+  required EServiceDocumentV1 document = 3;
+  required bool isInterface = 4;
+  repeated string serverUrls = 5;
+}
+
+message EServiceDocumentDeletedV1 {
+  required string eserviceId = 1;
+  required string descriptorId = 2;
+  required string documentId = 3;
+}
+
+message EServiceDescriptorAddedV1 {
+  required string eserviceId = 1;
+  required EServiceDescriptorV1 eserviceDescriptor = 2;
+}
+
+message EServiceDescriptorUpdatedV1 {
+  required string eserviceId = 1;
+  required EServiceDescriptorV1 eserviceDescriptor = 2;
+}
+
+message MovedAttributesFromEserviceToDescriptorsV1 {
+  required EServiceV1 eservice = 1;
+}
+