@pagopa/interop-outbound-models 1.0.0

package/dist/gen/v2/tenant/tenant.js

@@ -0,0 +1,722 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * @generated from protobuf enum tenant.v2.TenantKindV2
+ */
+export var TenantKindV2;
+(function (TenantKindV2) {
+    /**
+     * @generated from protobuf enum value: PA = 0;
+     */
+    TenantKindV2[TenantKindV2["PA"] = 0] = "PA";
+    /**
+     * @generated from protobuf enum value: GSP = 1;
+     */
+    TenantKindV2[TenantKindV2["GSP"] = 1] = "GSP";
+    /**
+     * @generated from protobuf enum value: PRIVATE = 2;
+     */
+    TenantKindV2[TenantKindV2["PRIVATE"] = 2] = "PRIVATE";
+})(TenantKindV2 || (TenantKindV2 = {}));
+/**
+ * @generated from protobuf enum tenant.v2.TenantUnitTypeV2
+ */
+export var TenantUnitTypeV2;
+(function (TenantUnitTypeV2) {
+    /**
+     * @generated from protobuf enum value: AOO = 0;
+     */
+    TenantUnitTypeV2[TenantUnitTypeV2["AOO"] = 0] = "AOO";
+    /**
+     * @generated from protobuf enum value: UO = 1;
+     */
+    TenantUnitTypeV2[TenantUnitTypeV2["UO"] = 1] = "UO";
+})(TenantUnitTypeV2 || (TenantUnitTypeV2 = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.TenantV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "selfcareId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "externalId", kind: "message", T: () => ExternalIdV2 },
+            { no: 4, name: "features", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => TenantFeatureV2 },
+            { no: 5, name: "attributes", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => TenantAttributeV2 },
+            { no: 6, name: "createdAt", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 7, name: "updatedAt", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 8, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 9, name: "kind", kind: "enum", opt: true, T: () => ["tenant.v2.TenantKindV2", TenantKindV2] },
+            { no: 10, name: "onboardedAt", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 11, name: "subUnitType", kind: "enum", opt: true, T: () => ["tenant.v2.TenantUnitTypeV2", TenantUnitTypeV2] }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.selfcareId = "";
+        message.features = [];
+        message.attributes = [];
+        message.createdAt = 0n;
+        message.name = "";
+        message.onboardedAt = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* string selfcareId */ 2:
+                    message.selfcareId = reader.string();
+                    break;
+                case /* tenant.v2.ExternalIdV2 externalId */ 3:
+                    message.externalId = ExternalIdV2.internalBinaryRead(reader, reader.uint32(), options, message.externalId);
+                    break;
+                case /* repeated tenant.v2.TenantFeatureV2 features */ 4:
+                    message.features.push(TenantFeatureV2.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated tenant.v2.TenantAttributeV2 attributes */ 5:
+                    message.attributes.push(TenantAttributeV2.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* int64 createdAt */ 6:
+                    message.createdAt = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 updatedAt */ 7:
+                    message.updatedAt = reader.int64().toBigInt();
+                    break;
+                case /* string name */ 8:
+                    message.name = reader.string();
+                    break;
+                case /* optional tenant.v2.TenantKindV2 kind */ 9:
+                    message.kind = reader.int32();
+                    break;
+                case /* int64 onboardedAt */ 10:
+                    message.onboardedAt = reader.int64().toBigInt();
+                    break;
+                case /* optional tenant.v2.TenantUnitTypeV2 subUnitType */ 11:
+                    message.subUnitType = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* string selfcareId = 2; */
+        if (message.selfcareId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.selfcareId);
+        /* tenant.v2.ExternalIdV2 externalId = 3; */
+        if (message.externalId)
+            ExternalIdV2.internalBinaryWrite(message.externalId, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated tenant.v2.TenantFeatureV2 features = 4; */
+        for (let i = 0; i < message.features.length; i++)
+            TenantFeatureV2.internalBinaryWrite(message.features[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* repeated tenant.v2.TenantAttributeV2 attributes = 5; */
+        for (let i = 0; i < message.attributes.length; i++)
+            TenantAttributeV2.internalBinaryWrite(message.attributes[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* int64 createdAt = 6; */
+        if (message.createdAt !== 0n)
+            writer.tag(6, WireType.Varint).int64(message.createdAt);
+        /* optional int64 updatedAt = 7; */
+        if (message.updatedAt !== undefined)
+            writer.tag(7, WireType.Varint).int64(message.updatedAt);
+        /* string name = 8; */
+        if (message.name !== "")
+            writer.tag(8, WireType.LengthDelimited).string(message.name);
+        /* optional tenant.v2.TenantKindV2 kind = 9; */
+        if (message.kind !== undefined)
+            writer.tag(9, WireType.Varint).int32(message.kind);
+        /* int64 onboardedAt = 10; */
+        if (message.onboardedAt !== 0n)
+            writer.tag(10, WireType.Varint).int64(message.onboardedAt);
+        /* optional tenant.v2.TenantUnitTypeV2 subUnitType = 11; */
+        if (message.subUnitType !== undefined)
+            writer.tag(11, WireType.Varint).int32(message.subUnitType);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.TenantV2
+ */
+export const TenantV2 = new TenantV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantFeatureV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.TenantFeatureV2", [
+            { no: 1, name: "certifier", kind: "message", oneof: "sealedValue", T: () => CertifierV2 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.sealedValue = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* tenant.v2.CertifierV2 certifier */ 1:
+                    message.sealedValue = {
+                        oneofKind: "certifier",
+                        certifier: CertifierV2.internalBinaryRead(reader, reader.uint32(), options, message.sealedValue.certifier)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* tenant.v2.CertifierV2 certifier = 1; */
+        if (message.sealedValue.oneofKind === "certifier")
+            CertifierV2.internalBinaryWrite(message.sealedValue.certifier, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.TenantFeatureV2
+ */
+export const TenantFeatureV2 = new TenantFeatureV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CertifierV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.CertifierV2", [
+            { no: 1, name: "certifierId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.certifierId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string certifierId */ 1:
+                    message.certifierId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string certifierId = 1; */
+        if (message.certifierId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.certifierId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.CertifierV2
+ */
+export const CertifierV2 = new CertifierV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantVerifierV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.TenantVerifierV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "verificationDate", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "expirationDate", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 4, name: "extensionDate", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.verificationDate = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* int64 verificationDate */ 2:
+                    message.verificationDate = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 expirationDate */ 3:
+                    message.expirationDate = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 extensionDate */ 4:
+                    message.extensionDate = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* int64 verificationDate = 2; */
+        if (message.verificationDate !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.verificationDate);
+        /* optional int64 expirationDate = 3; */
+        if (message.expirationDate !== undefined)
+            writer.tag(3, WireType.Varint).int64(message.expirationDate);
+        /* optional int64 extensionDate = 4; */
+        if (message.extensionDate !== undefined)
+            writer.tag(4, WireType.Varint).int64(message.extensionDate);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.TenantVerifierV2
+ */
+export const TenantVerifierV2 = new TenantVerifierV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantRevokerV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.TenantRevokerV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "verificationDate", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "expirationDate", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 4, name: "extensionDate", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 5, name: "revocationDate", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.verificationDate = 0n;
+        message.revocationDate = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* int64 verificationDate */ 2:
+                    message.verificationDate = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 expirationDate */ 3:
+                    message.expirationDate = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 extensionDate */ 4:
+                    message.extensionDate = reader.int64().toBigInt();
+                    break;
+                case /* int64 revocationDate */ 5:
+                    message.revocationDate = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* int64 verificationDate = 2; */
+        if (message.verificationDate !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.verificationDate);
+        /* optional int64 expirationDate = 3; */
+        if (message.expirationDate !== undefined)
+            writer.tag(3, WireType.Varint).int64(message.expirationDate);
+        /* optional int64 extensionDate = 4; */
+        if (message.extensionDate !== undefined)
+            writer.tag(4, WireType.Varint).int64(message.extensionDate);
+        /* int64 revocationDate = 5; */
+        if (message.revocationDate !== 0n)
+            writer.tag(5, WireType.Varint).int64(message.revocationDate);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.TenantRevokerV2
+ */
+export const TenantRevokerV2 = new TenantRevokerV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExternalIdV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.ExternalIdV2", [
+            { no: 1, name: "origin", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.origin = "";
+        message.value = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string origin */ 1:
+                    message.origin = reader.string();
+                    break;
+                case /* string value */ 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string origin = 1; */
+        if (message.origin !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.origin);
+        /* string value = 2; */
+        if (message.value !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.value);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.ExternalIdV2
+ */
+export const ExternalIdV2 = new ExternalIdV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantCertifiedAttributeV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.TenantCertifiedAttributeV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "assignmentTimestamp", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "revocationTimestamp", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.assignmentTimestamp = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* int64 assignmentTimestamp */ 2:
+                    message.assignmentTimestamp = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 revocationTimestamp */ 3:
+                    message.revocationTimestamp = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* int64 assignmentTimestamp = 2; */
+        if (message.assignmentTimestamp !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.assignmentTimestamp);
+        /* optional int64 revocationTimestamp = 3; */
+        if (message.revocationTimestamp !== undefined)
+            writer.tag(3, WireType.Varint).int64(message.revocationTimestamp);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.TenantCertifiedAttributeV2
+ */
+export const TenantCertifiedAttributeV2 = new TenantCertifiedAttributeV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantDeclaredAttributeV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.TenantDeclaredAttributeV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "assignmentTimestamp", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "revocationTimestamp", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.assignmentTimestamp = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* int64 assignmentTimestamp */ 2:
+                    message.assignmentTimestamp = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 revocationTimestamp */ 3:
+                    message.revocationTimestamp = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* int64 assignmentTimestamp = 2; */
+        if (message.assignmentTimestamp !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.assignmentTimestamp);
+        /* optional int64 revocationTimestamp = 3; */
+        if (message.revocationTimestamp !== undefined)
+            writer.tag(3, WireType.Varint).int64(message.revocationTimestamp);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.TenantDeclaredAttributeV2
+ */
+export const TenantDeclaredAttributeV2 = new TenantDeclaredAttributeV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantVerifiedAttributeV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.TenantVerifiedAttributeV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "assignmentTimestamp", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "verifiedBy", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => TenantVerifierV2 },
+            { no: 4, name: "revokedBy", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => TenantRevokerV2 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.assignmentTimestamp = 0n;
+        message.verifiedBy = [];
+        message.revokedBy = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* int64 assignmentTimestamp */ 2:
+                    message.assignmentTimestamp = reader.int64().toBigInt();
+                    break;
+                case /* repeated tenant.v2.TenantVerifierV2 verifiedBy */ 3:
+                    message.verifiedBy.push(TenantVerifierV2.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated tenant.v2.TenantRevokerV2 revokedBy */ 4:
+                    message.revokedBy.push(TenantRevokerV2.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* int64 assignmentTimestamp = 2; */
+        if (message.assignmentTimestamp !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.assignmentTimestamp);
+        /* repeated tenant.v2.TenantVerifierV2 verifiedBy = 3; */
+        for (let i = 0; i < message.verifiedBy.length; i++)
+            TenantVerifierV2.internalBinaryWrite(message.verifiedBy[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated tenant.v2.TenantRevokerV2 revokedBy = 4; */
+        for (let i = 0; i < message.revokedBy.length; i++)
+            TenantRevokerV2.internalBinaryWrite(message.revokedBy[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.TenantVerifiedAttributeV2
+ */
+export const TenantVerifiedAttributeV2 = new TenantVerifiedAttributeV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantAttributeV2$Type extends MessageType {
+    constructor() {
+        super("tenant.v2.TenantAttributeV2", [
+            { no: 1, name: "certifiedAttribute", kind: "message", oneof: "sealedValue", T: () => TenantCertifiedAttributeV2 },
+            { no: 2, name: "declaredAttribute", kind: "message", oneof: "sealedValue", T: () => TenantDeclaredAttributeV2 },
+            { no: 3, name: "verifiedAttribute", kind: "message", oneof: "sealedValue", T: () => TenantVerifiedAttributeV2 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.sealedValue = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* tenant.v2.TenantCertifiedAttributeV2 certifiedAttribute */ 1:
+                    message.sealedValue = {
+                        oneofKind: "certifiedAttribute",
+                        certifiedAttribute: TenantCertifiedAttributeV2.internalBinaryRead(reader, reader.uint32(), options, message.sealedValue.certifiedAttribute)
+                    };
+                    break;
+                case /* tenant.v2.TenantDeclaredAttributeV2 declaredAttribute */ 2:
+                    message.sealedValue = {
+                        oneofKind: "declaredAttribute",
+                        declaredAttribute: TenantDeclaredAttributeV2.internalBinaryRead(reader, reader.uint32(), options, message.sealedValue.declaredAttribute)
+                    };
+                    break;
+                case /* tenant.v2.TenantVerifiedAttributeV2 verifiedAttribute */ 3:
+                    message.sealedValue = {
+                        oneofKind: "verifiedAttribute",
+                        verifiedAttribute: TenantVerifiedAttributeV2.internalBinaryRead(reader, reader.uint32(), options, message.sealedValue.verifiedAttribute)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* tenant.v2.TenantCertifiedAttributeV2 certifiedAttribute = 1; */
+        if (message.sealedValue.oneofKind === "certifiedAttribute")
+            TenantCertifiedAttributeV2.internalBinaryWrite(message.sealedValue.certifiedAttribute, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* tenant.v2.TenantDeclaredAttributeV2 declaredAttribute = 2; */
+        if (message.sealedValue.oneofKind === "declaredAttribute")
+            TenantDeclaredAttributeV2.internalBinaryWrite(message.sealedValue.declaredAttribute, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* tenant.v2.TenantVerifiedAttributeV2 verifiedAttribute = 3; */
+        if (message.sealedValue.oneofKind === "verifiedAttribute")
+            TenantVerifiedAttributeV2.internalBinaryWrite(message.sealedValue.verifiedAttribute, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message tenant.v2.TenantAttributeV2
+ */
+export const TenantAttributeV2 = new TenantAttributeV2$Type();