@pagopa/interop-outbound-models 1.0.0

package/dist/purpose/index.d.ts

@@ -0,0 +1,228 @@
+import { z } from "zod";
+import { PurposeEventV1 } from "./eventsV1.js";
+import { PurposeEventV2 } from "./eventsV2.js";
+export declare function encodeOutboundPurposeEvent(event: PurposeEvent): string;
+export declare function decodeOutboundPurposeEvent(encodedEvent: string): PurposeEvent;
+export declare const PurposeEvent: 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: "PurposeCreated";
+    version: number;
+    data: import("../index.js").PurposeCreatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeUpdated";
+    version: number;
+    data: import("../index.js").PurposeUpdatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeVersionWaitedForApproval";
+    version: number;
+    data: import("../index.js").PurposeVersionWaitedForApprovalV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeVersionActivated";
+    version: number;
+    data: import("../index.js").PurposeVersionActivatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeVersionCreated";
+    version: number;
+    data: import("../index.js").PurposeVersionCreatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeVersionSuspended";
+    version: number;
+    data: import("../index.js").PurposeVersionSuspendedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeVersionArchived";
+    version: number;
+    data: import("../index.js").PurposeVersionArchivedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeVersionUpdated";
+    version: number;
+    data: import("../index.js").PurposeVersionUpdatedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeVersionDeleted";
+    version: number;
+    data: import("../index.js").PurposeVersionDeletedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeDeleted";
+    version: number;
+    data: import("../index.js").PurposeDeletedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 1;
+    type: "PurposeVersionRejected";
+    version: number;
+    data: import("../index.js").PurposeVersionRejectedV1;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeAdded";
+    version: number;
+    data: import("../index.js").PurposeAddedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "DraftPurposeUpdated";
+    version: number;
+    data: import("../index.js").DraftPurposeUpdatedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeWaitingForApproval";
+    version: number;
+    data: import("../index.js").PurposeWaitingForApprovalV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeActivated";
+    version: number;
+    data: import("../index.js").PurposeActivatedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "DraftPurposeDeleted";
+    version: number;
+    data: import("../index.js").DraftPurposeDeletedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "WaitingForApprovalPurposeDeleted";
+    version: number;
+    data: import("../index.js").WaitingForApprovalPurposeDeletedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "NewPurposeVersionActivated";
+    version: number;
+    data: import("../index.js").NewPurposeVersionActivatedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeVersionActivated";
+    version: number;
+    data: import("../index.js").PurposeVersionActivatedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeVersionUnsuspendedByProducer";
+    version: number;
+    data: import("../index.js").PurposeVersionUnsuspendedByProducerV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeVersionUnsuspendedByConsumer";
+    version: number;
+    data: import("../index.js").PurposeVersionUnsuspendedByConsumerV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeVersionSuspendedByProducer";
+    version: number;
+    data: import("../index.js").PurposeVersionSuspendedByProducerV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeVersionSuspendedByConsumer";
+    version: number;
+    data: import("../index.js").PurposeVersionSuspendedByConsumerV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "NewPurposeVersionWaitingForApproval";
+    version: number;
+    data: import("../index.js").NewPurposeVersionWaitingForApprovalV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeVersionOverQuotaUnsuspended";
+    version: number;
+    data: import("../index.js").PurposeVersionOverQuotaUnsuspendedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeArchived";
+    version: number;
+    data: import("../index.js").PurposeArchivedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "WaitingForApprovalPurposeVersionDeleted";
+    version: number;
+    data: import("../index.js").WaitingForApprovalPurposeVersionDeletedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeVersionRejected";
+    version: number;
+    data: import("../index.js").PurposeVersionRejectedV2;
+    stream_id: string;
+    timestamp: Date;
+} | {
+    event_version: 2;
+    type: "PurposeCloned";
+    version: number;
+    data: import("../index.js").PurposeClonedV2;
+    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 PurposeEvent = z.infer<typeof PurposeEvent>;
+export { PurposeEventV1, PurposeEventV2 };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/purpose/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,cAAc,EAA8B,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,cAAc,EAA8B,MAAM,eAAe,CAAC;AAS3E,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAStE;AAED,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,MAAM,GAAG,YAAY,CAE7E;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAWvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC"}

package/dist/purpose/index.js

@@ -0,0 +1,36 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { VersionedEvent } from "../utils.js";
+import { PurposeEventV1, purposeEventToBinaryDataV1 } from "./eventsV1.js";
+import { PurposeEventV2, purposeEventToBinaryDataV2 } from "./eventsV2.js";
+function purposeEventToBinaryData(event) {
+    return match(event)
+        .with({ event_version: 1 }, purposeEventToBinaryDataV1)
+        .with({ event_version: 2 }, purposeEventToBinaryDataV2)
+        .exhaustive();
+}
+export function encodeOutboundPurposeEvent(event) {
+    return JSON.stringify({
+        event_version: event.event_version,
+        type: event.type,
+        data: purposeEventToBinaryData(event),
+        stream_id: event.stream_id,
+        version: event.version,
+        timestamp: event.timestamp,
+    });
+}
+export function decodeOutboundPurposeEvent(encodedEvent) {
+    return PurposeEvent.parse(JSON.parse(encodedEvent));
+}
+export const PurposeEvent = VersionedEvent.transform((obj, ctx) => {
+    const res = match(obj)
+        .with({ event_version: 1 }, () => PurposeEventV1.safeParse(obj))
+        .with({ event_version: 2 }, () => PurposeEventV2.safeParse(obj))
+        .exhaustive();
+    if (!res.success) {
+        res.error.issues.forEach(ctx.addIssue);
+        return z.NEVER;
+    }
+    return res.data;
+});
+export { PurposeEventV1, PurposeEventV2 };

package/dist/tenant/eventsV1.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { TenantCreatedV1, TenantUpdatedV1, TenantDeletedV1 } from "../gen/v1/tenant/events.js";
+export declare function tenantEventToBinaryDataV1(event: TenantEventV1): Uint8Array;
+export declare const TenantEventV1: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"TenantCreated">;
+    data: z.ZodEffects<z.ZodAny, TenantCreatedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "TenantCreated";
+    version: number;
+    data: TenantCreatedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "TenantCreated";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"TenantUpdated">;
+    data: z.ZodEffects<z.ZodAny, TenantUpdatedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "TenantUpdated";
+    version: number;
+    data: TenantUpdatedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "TenantUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"TenantDeleted">;
+    data: z.ZodEffects<z.ZodAny, TenantDeletedV1, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 1;
+    type: "TenantDeleted";
+    version: number;
+    data: TenantDeletedV1;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 1;
+    type: "TenantDeleted";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>]>;
+export type TenantEventV1 = z.infer<typeof TenantEventV1>;
+//# sourceMappingURL=eventsV1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eventsV1.d.ts","sourceRoot":"","sources":["../../src/tenant/eventsV1.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,eAAe,EACf,eAAe,EACf,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAGpC,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa,GAAG,UAAU,CAY1E;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyBxB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/tenant/eventsV1.js

@@ -0,0 +1,37 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { TenantCreatedV1, TenantUpdatedV1, TenantDeletedV1, } from "../gen/v1/tenant/events.js";
+import { protobufDecoder } from "../utils.js";
+export function tenantEventToBinaryDataV1(event) {
+    return match(event)
+        .with({ type: "TenantCreated" }, ({ data }) => TenantCreatedV1.toBinary(data))
+        .with({ type: "TenantUpdated" }, ({ data }) => TenantUpdatedV1.toBinary(data))
+        .with({ type: "TenantDeleted" }, ({ data }) => TenantDeletedV1.toBinary(data))
+        .exhaustive();
+}
+export const TenantEventV1 = z.discriminatedUnion("type", [
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("TenantCreated"),
+        data: protobufDecoder(TenantCreatedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("TenantUpdated"),
+        data: protobufDecoder(TenantUpdatedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+    z.object({
+        event_version: z.literal(1),
+        type: z.literal("TenantDeleted"),
+        data: protobufDecoder(TenantDeletedV1),
+        stream_id: z.string(),
+        version: z.number(),
+        timestamp: z.coerce.date(),
+    }),
+]);

package/dist/tenant/eventsV2.d.ts

@@ -0,0 +1,258 @@
+import { z } from "zod";
+import { TenantOnboardedV2, TenantOnboardDetailsUpdatedV2, TenantCertifiedAttributeAssignedV2, TenantCertifiedAttributeRevokedV2, TenantDeclaredAttributeAssignedV2, TenantDeclaredAttributeRevokedV2, TenantVerifiedAttributeAssignedV2, TenantVerifiedAttributeRevokedV2, TenantVerifiedAttributeExpirationUpdatedV2, MaintenanceTenantDeletedV2, TenantVerifiedAttributeExtensionUpdatedV2, TenantKindUpdatedV2 } from "../gen/v2/tenant/events.js";
+export declare function tenantEventToBinaryDataV2(event: TenantEventV2): Uint8Array;
+export declare const TenantEventV2: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantOnboarded">;
+    data: z.ZodEffects<z.ZodAny, TenantOnboardedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantOnboarded";
+    version: number;
+    data: TenantOnboardedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantOnboarded";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantOnboardDetailsUpdated">;
+    data: z.ZodEffects<z.ZodAny, TenantOnboardDetailsUpdatedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantOnboardDetailsUpdated";
+    version: number;
+    data: TenantOnboardDetailsUpdatedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantOnboardDetailsUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantCertifiedAttributeAssigned">;
+    data: z.ZodEffects<z.ZodAny, TenantCertifiedAttributeAssignedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantCertifiedAttributeAssigned";
+    version: number;
+    data: TenantCertifiedAttributeAssignedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantCertifiedAttributeAssigned";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantCertifiedAttributeRevoked">;
+    data: z.ZodEffects<z.ZodAny, TenantCertifiedAttributeRevokedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantCertifiedAttributeRevoked";
+    version: number;
+    data: TenantCertifiedAttributeRevokedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantCertifiedAttributeRevoked";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantDeclaredAttributeAssigned">;
+    data: z.ZodEffects<z.ZodAny, TenantDeclaredAttributeAssignedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantDeclaredAttributeAssigned";
+    version: number;
+    data: TenantDeclaredAttributeAssignedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantDeclaredAttributeAssigned";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantDeclaredAttributeRevoked">;
+    data: z.ZodEffects<z.ZodAny, TenantDeclaredAttributeRevokedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantDeclaredAttributeRevoked";
+    version: number;
+    data: TenantDeclaredAttributeRevokedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantDeclaredAttributeRevoked";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantVerifiedAttributeAssigned">;
+    data: z.ZodEffects<z.ZodAny, TenantVerifiedAttributeAssignedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantVerifiedAttributeAssigned";
+    version: number;
+    data: TenantVerifiedAttributeAssignedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantVerifiedAttributeAssigned";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantVerifiedAttributeRevoked">;
+    data: z.ZodEffects<z.ZodAny, TenantVerifiedAttributeRevokedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantVerifiedAttributeRevoked";
+    version: number;
+    data: TenantVerifiedAttributeRevokedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantVerifiedAttributeRevoked";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantVerifiedAttributeExpirationUpdated">;
+    data: z.ZodEffects<z.ZodAny, TenantVerifiedAttributeExpirationUpdatedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantVerifiedAttributeExpirationUpdated";
+    version: number;
+    data: TenantVerifiedAttributeExpirationUpdatedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantVerifiedAttributeExpirationUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantVerifiedAttributeExtensionUpdated">;
+    data: z.ZodEffects<z.ZodAny, TenantVerifiedAttributeExtensionUpdatedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantVerifiedAttributeExtensionUpdated";
+    version: number;
+    data: TenantVerifiedAttributeExtensionUpdatedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantVerifiedAttributeExtensionUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"MaintenanceTenantDeleted">;
+    data: z.ZodEffects<z.ZodAny, MaintenanceTenantDeletedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "MaintenanceTenantDeleted";
+    version: number;
+    data: MaintenanceTenantDeletedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "MaintenanceTenantDeleted";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>, z.ZodObject<{
+    event_version: z.ZodLiteral<2>;
+    type: z.ZodLiteral<"TenantKindUpdated">;
+    data: z.ZodEffects<z.ZodAny, TenantKindUpdatedV2, any>;
+    stream_id: z.ZodString;
+    version: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    event_version: 2;
+    type: "TenantKindUpdated";
+    version: number;
+    data: TenantKindUpdatedV2;
+    stream_id: string;
+    timestamp: Date;
+}, {
+    event_version: 2;
+    type: "TenantKindUpdated";
+    version: number;
+    stream_id: string;
+    timestamp: Date;
+    data?: any;
+}>]>;
+export type TenantEventV2 = z.infer<typeof TenantEventV2>;
+//# sourceMappingURL=eventsV2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eventsV2.d.ts","sourceRoot":"","sources":["../../src/tenant/eventsV2.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,iBAAiB,EACjB,6BAA6B,EAC7B,kCAAkC,EAClC,iCAAiC,EACjC,iCAAiC,EACjC,gCAAgC,EAChC,iCAAiC,EACjC,gCAAgC,EAChC,0CAA0C,EAC1C,0BAA0B,EAC1B,yCAAyC,EACzC,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AAGpC,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa,GAAG,UAAU,CAuC1E;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiGxB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}