@pagopa/interop-outbound-models 1.7.2 → 1.8.0

package/dist/purpose-template/eventsV2.d.ts

@@ -0,0 +1,258 @@
+import { z } from "zod";
+import { PurposeTemplateAddedV2, PurposeTemplateAnnotationDocumentAddedV2, PurposeTemplateAnnotationDocumentDeletedV2, PurposeTemplateAnnotationDocumentUpdatedV2, PurposeTemplateArchivedV2, PurposeTemplateDraftDeletedV2, PurposeTemplateDraftUpdatedV2, PurposeTemplateEServiceLinkedV2, PurposeTemplateEServiceUnlinkedV2, PurposeTemplatePublishedV2, PurposeTemplateSuspendedV2, PurposeTemplateUnsuspendedV2 } from "../gen/v2/purpose-template/events.js";
+export declare function purposeTemplateEventToBinaryDataV2(event: PurposeTemplateEventV2): Uint8Array;
+export declare const PurposeTemplateEventV2: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateAdded">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateAddedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateAdded";
+    version: number;
+    data: PurposeTemplateAddedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateAdded";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateEServiceLinked">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateEServiceLinkedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateEServiceLinked";
+    version: number;
+    data: PurposeTemplateEServiceLinkedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateEServiceLinked";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateEServiceUnlinked">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateEServiceUnlinkedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateEServiceUnlinked";
+    version: number;
+    data: PurposeTemplateEServiceUnlinkedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateEServiceUnlinked";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateDraftUpdated">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateDraftUpdatedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateDraftUpdated";
+    version: number;
+    data: PurposeTemplateDraftUpdatedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateDraftUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateDraftDeleted">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateDraftDeletedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateDraftDeleted";
+    version: number;
+    data: PurposeTemplateDraftDeletedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateDraftDeleted";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplatePublished">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplatePublishedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplatePublished";
+    version: number;
+    data: PurposeTemplatePublishedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplatePublished";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateUnsuspended">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateUnsuspendedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateUnsuspended";
+    version: number;
+    data: PurposeTemplateUnsuspendedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateUnsuspended";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateSuspended">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateSuspendedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateSuspended";
+    version: number;
+    data: PurposeTemplateSuspendedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateSuspended";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateArchived">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateArchivedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateArchived";
+    version: number;
+    data: PurposeTemplateArchivedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateArchived";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateAnnotationDocumentAdded">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateAnnotationDocumentAddedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateAnnotationDocumentAdded";
+    version: number;
+    data: PurposeTemplateAnnotationDocumentAddedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateAnnotationDocumentAdded";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateAnnotationDocumentDeleted">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateAnnotationDocumentDeletedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateAnnotationDocumentDeleted";
+    version: number;
+    data: PurposeTemplateAnnotationDocumentDeletedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateAnnotationDocumentDeleted";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"PurposeTemplateAnnotationDocumentUpdated">;
+    data: z.ZodEffects<z.ZodAny, PurposeTemplateAnnotationDocumentUpdatedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "PurposeTemplateAnnotationDocumentUpdated";
+    version: number;
+    data: PurposeTemplateAnnotationDocumentUpdatedV2;
+    stream_id: string;
+    timestamp: string;
+}, {
+    event_version: 2;
+    type: "PurposeTemplateAnnotationDocumentUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: string;
+    data?: any;
+}>]>;
+export type PurposeTemplateEventV2 = z.infer<typeof PurposeTemplateEventV2>;
+//# sourceMappingURL=eventsV2.d.ts.map

package/dist/purpose-template/eventsV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventsV2.d.ts","sourceRoot":"","sources":["../../src/purpose-template/eventsV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,sBAAsB,EACtB,wCAAwC,EACxC,0CAA0C,EAC1C,0CAA0C,EAC1C,yBAAyB,EACzB,6BAA6B,EAC7B,6BAA6B,EAC7B,+BAA+B,EAC/B,iCAAiC,EACjC,0BAA0B,EAC1B,0BAA0B,EAC1B,4BAA4B,EAC7B,MAAM,sCAAsC,CAAC;AAG9C,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,sBAAsB,GAC5B,UAAU,CAuCZ;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiGjC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/purpose-template/eventsV2.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { match } from "ts-pattern";
+import { PurposeTemplateAddedV2, PurposeTemplateAnnotationDocumentAddedV2, PurposeTemplateAnnotationDocumentDeletedV2, PurposeTemplateAnnotationDocumentUpdatedV2, PurposeTemplateArchivedV2, PurposeTemplateDraftDeletedV2, PurposeTemplateDraftUpdatedV2, PurposeTemplateEServiceLinkedV2, PurposeTemplateEServiceUnlinkedV2, PurposeTemplatePublishedV2, PurposeTemplateSuspendedV2, PurposeTemplateUnsuspendedV2, } from "../gen/v2/purpose-template/events.js";
+import { protobufDecoder } from "../utils.js";
+export function purposeTemplateEventToBinaryDataV2(event) {
+    return match(event)
+        .with({ type: "PurposeTemplateAdded" }, ({ data }) => PurposeTemplateAddedV2.toBinary(data))
+        .with({ type: "PurposeTemplateEServiceLinked" }, ({ data }) => PurposeTemplateEServiceLinkedV2.toBinary(data))
+        .with({ type: "PurposeTemplateEServiceUnlinked" }, ({ data }) => PurposeTemplateEServiceUnlinkedV2.toBinary(data))
+        .with({ type: "PurposeTemplateDraftUpdated" }, ({ data }) => PurposeTemplateDraftUpdatedV2.toBinary(data))
+        .with({ type: "PurposeTemplateDraftDeleted" }, ({ data }) => PurposeTemplateDraftDeletedV2.toBinary(data))
+        .with({ type: "PurposeTemplatePublished" }, ({ data }) => PurposeTemplatePublishedV2.toBinary(data))
+        .with({ type: "PurposeTemplateUnsuspended" }, ({ data }) => PurposeTemplateUnsuspendedV2.toBinary(data))
+        .with({ type: "PurposeTemplateSuspended" }, ({ data }) => PurposeTemplateSuspendedV2.toBinary(data))
+        .with({ type: "PurposeTemplateArchived" }, ({ data }) => PurposeTemplateArchivedV2.toBinary(data))
+        .with({ type: "PurposeTemplateAnnotationDocumentAdded" }, ({ data }) => PurposeTemplateAnnotationDocumentAddedV2.toBinary(data))
+        .with({ type: "PurposeTemplateAnnotationDocumentDeleted" }, ({ data }) => PurposeTemplateAnnotationDocumentDeletedV2.toBinary(data))
+        .with({ type: "PurposeTemplateAnnotationDocumentUpdated" }, ({ data }) => PurposeTemplateAnnotationDocumentUpdatedV2.toBinary(data))
+        .exhaustive();
+}
+export const PurposeTemplateEventV2 = z.discriminatedUnion("type", [
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateAdded"),
+        data: protobufDecoder(PurposeTemplateAddedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateEServiceLinked"),
+        data: protobufDecoder(PurposeTemplateEServiceLinkedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateEServiceUnlinked"),
+        data: protobufDecoder(PurposeTemplateEServiceUnlinkedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateDraftUpdated"),
+        data: protobufDecoder(PurposeTemplateDraftUpdatedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateDraftDeleted"),
+        data: protobufDecoder(PurposeTemplateDraftDeletedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplatePublished"),
+        data: protobufDecoder(PurposeTemplatePublishedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateUnsuspended"),
+        data: protobufDecoder(PurposeTemplateUnsuspendedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateSuspended"),
+        data: protobufDecoder(PurposeTemplateSuspendedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateArchived"),
+        data: protobufDecoder(PurposeTemplateArchivedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateAnnotationDocumentAdded"),
+        data: protobufDecoder(PurposeTemplateAnnotationDocumentAddedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateAnnotationDocumentDeleted"),
+        data: protobufDecoder(PurposeTemplateAnnotationDocumentDeletedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+    z.object({
+        event_version: z.literal(2),
+        type: z.literal("PurposeTemplateAnnotationDocumentUpdated"),
+        data: protobufDecoder(PurposeTemplateAnnotationDocumentUpdatedV2),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.string(),
+    }),
+]);

package/dist/purpose-template/index.d.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import { PurposeTemplateEventV2 } from "./eventsV2.js";
+export declare function purposeTemplateEventToBinaryData(event: PurposeTemplateEvent): Uint8Array;
+export declare function encodeOutboundPurposeTemplateEvent(event: PurposeTemplateEvent): string;
+export declare function decodeOutboundPurposeTemplateEvent(encodedEvent: string): PurposeTemplateEvent;
+export declare const PurposeTemplateEvent: 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: 2;
+    type: "PurposeTemplateAdded";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateAddedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateEServiceLinked";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateEServiceLinkedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateEServiceUnlinked";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateEServiceUnlinkedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateDraftUpdated";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateDraftUpdatedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateDraftDeleted";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateDraftDeletedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplatePublished";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplatePublishedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateUnsuspended";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateUnsuspendedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateSuspended";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateSuspendedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateArchived";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateArchivedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateAnnotationDocumentAdded";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateAnnotationDocumentAddedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateAnnotationDocumentDeleted";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateAnnotationDocumentDeletedV2;
+    stream_id: string;
+    timestamp: string;
+} | {
+    event_version: 2;
+    type: "PurposeTemplateAnnotationDocumentUpdated";
+    version: number;
+    data: import("../gen/v2/purpose-template/events.js").PurposeTemplateAnnotationDocumentUpdatedV2;
+    stream_id: string;
+    timestamp: string;
+}, z.objectInputType<{
+    event_version: z.ZodLiteral<1>;
+}, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+    event_version: z.ZodLiteral<2>;
+}, z.ZodTypeAny, "passthrough">>;
+export type PurposeTemplateEventType = PurposeTemplateEvent["type"];
+export type PurposeTemplateEvent = z.infer<typeof PurposeTemplateEvent>;
+export { PurposeTemplateEventV2 };
+//# sourceMappingURL=index.d.ts.map

package/dist/purpose-template/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/purpose-template/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,sBAAsB,EAEvB,MAAM,eAAe,CAAC;AAEvB,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,oBAAoB,GAC1B,UAAU,CAIZ;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,oBAAoB,GAC1B,MAAM,CASR;AAED,wBAAgB,kCAAkC,CAChD,YAAY,EAAE,MAAM,GACnB,oBAAoB,CAEtB;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAa/B,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/purpose-template/index.js

@@ -0,0 +1,36 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { VersionedEvent } from "../utils.js";
+import { PurposeTemplateEventV2, purposeTemplateEventToBinaryDataV2, } from "./eventsV2.js";
+export function purposeTemplateEventToBinaryData(event) {
+    return match(event)
+        .with({ event_version: 2 }, purposeTemplateEventToBinaryDataV2)
+        .exhaustive();
+}
+export function encodeOutboundPurposeTemplateEvent(event) {
+    return JSON.stringify({
+        event_version: event.event_version,
+        type: event.type,
+        data: Buffer.from(purposeTemplateEventToBinaryData(event)).toString("hex"),
+        stream_id: event.stream_id,
+        version: event.version,
+        timestamp: event.timestamp,
+    });
+}
+export function decodeOutboundPurposeTemplateEvent(encodedEvent) {
+    return PurposeTemplateEvent.parse(JSON.parse(encodedEvent));
+}
+export const PurposeTemplateEvent = VersionedEvent.transform((obj, ctx) => {
+    const res = match(obj)
+        .with({ event_version: 1 }, () => {
+        throw new Error("Unsupported event version");
+    })
+        .with({ event_version: 2 }, () => PurposeTemplateEventV2.safeParse(obj))
+        .exhaustive();
+    if (!res.success) {
+        res.error.issues.forEach(ctx.addIssue);
+        return z.NEVER;
+    }
+    return res.data;
+});
+export { PurposeTemplateEventV2 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/interop-outbound-models",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "description": "PagoPA Interoperability outbound models",
   "main": "dist",
   "type": "module",

package/proto/v2/purpose-template/events.proto

@@ -0,0 +1,62 @@
+syntax = "proto3";
+
+package purpose.template.v2;
+
+import "v2/purpose-template/purpose-template.proto";
+import "v2/eservice/eservice.proto";
+
+message PurposeTemplateAddedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+}
+
+message PurposeTemplateEServiceLinkedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+  eservice.v2.EServiceV2 eservice = 2;
+  string descriptorId = 3;
+  int64 createdAt = 4;
+}
+
+message PurposeTemplateEServiceUnlinkedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+  eservice.v2.EServiceV2 eservice = 2;
+  string descriptorId = 3;
+}
+
+message PurposeTemplateDraftUpdatedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+}
+
+message PurposeTemplateDraftDeletedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+}
+
+message PurposeTemplatePublishedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+}
+
+message PurposeTemplateUnsuspendedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+}
+
+message PurposeTemplateSuspendedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+}
+
+message PurposeTemplateArchivedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+}
+
+message PurposeTemplateAnnotationDocumentAddedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+  string documentId = 2;
+}
+
+message PurposeTemplateAnnotationDocumentDeletedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+  string documentId = 2;
+}
+message PurposeTemplateAnnotationDocumentUpdatedV2 {
+  PurposeTemplateV2 purposeTemplate = 1;
+  string documentId = 2;
+  string answerId = 3;
+} 

package/proto/v2/purpose-template/purpose-template.proto

@@ -0,0 +1,69 @@
+syntax = "proto3";
+
+package purpose.template.v2;
+
+import "v2/tenant/tenant.proto";
+
+enum PurposeTemplateStateV2 {
+  DRAFT = 0;
+  PUBLISHED = 1;
+  SUSPENDED = 2;
+  ARCHIVED = 3;
+}
+
+message PurposeTemplateV2 {
+  string id = 1;
+  string targetDescription = 2;
+  tenant.v2.TenantKindV2 targetTenantKind = 3;
+  string creatorId = 4;
+  PurposeTemplateStateV2 state = 5;
+  int64 createdAt = 6;
+  optional int64 updatedAt = 7;
+  string purposeTitle = 8;
+  string purposeDescription = 9;
+  optional RiskAnalysisFormTemplateV2 purposeRiskAnalysisForm = 10;
+  bool purposeIsFreeOfCharge = 11;
+  optional string purposeFreeOfChargeReason = 12;
+  optional int32 purposeDailyCalls = 13;
+  bool handlesPersonalData = 14;
+}
+
+message RiskAnalysisFormTemplateV2 {
+  string id = 1;
+  string version = 2;
+  repeated RiskAnalysisTemplateSingleAnswerV2 singleAnswers = 3;
+  repeated RiskAnalysisTemplateMultiAnswerV2 multiAnswers = 4;
+}
+
+message RiskAnalysisTemplateSingleAnswerV2 {
+  string id = 1;
+  string key = 2;
+  optional string value = 3;
+  bool editable = 4;
+  optional RiskAnalysisTemplateAnswerAnnotationV2 annotation = 5;
+  repeated string suggestedValues = 6;
+}
+
+message RiskAnalysisTemplateMultiAnswerV2 {
+  string id = 1;
+  string key = 2;
+  repeated string values = 3;
+  bool editable = 4;
+  optional RiskAnalysisTemplateAnswerAnnotationV2 annotation = 5;
+}
+
+message RiskAnalysisTemplateAnswerAnnotationV2 {
+  string id = 1;
+  string text = 2;
+  repeated RiskAnalysisTemplateAnswerAnnotationDocumentV2 docs = 3;
+}
+
+message RiskAnalysisTemplateAnswerAnnotationDocumentV2 {
+  string id = 1;
+  string name = 2;
+  string prettyName = 3;
+  string contentType = 4;
+  string path = 5;
+  int64 createdAt = 6;
+  string checksum = 7;
+}