@pagopa/interop-outbound-models 1.0.0

package/dist/gen/v1/tenant/tenant.js

@@ -0,0 +1,727 @@
+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.TenantKindV1
+ */
+export var TenantKindV1;
+(function (TenantKindV1) {
+    /**
+     * @generated synthetic value - protobuf-ts requires all enums to have a 0 value
+     */
+    TenantKindV1[TenantKindV1["UNSPECIFIED$"] = 0] = "UNSPECIFIED$";
+    /**
+     * @generated from protobuf enum value: PA = 1;
+     */
+    TenantKindV1[TenantKindV1["PA"] = 1] = "PA";
+    /**
+     * @generated from protobuf enum value: GSP = 2;
+     */
+    TenantKindV1[TenantKindV1["GSP"] = 2] = "GSP";
+    /**
+     * @generated from protobuf enum value: PRIVATE = 3;
+     */
+    TenantKindV1[TenantKindV1["PRIVATE"] = 3] = "PRIVATE";
+})(TenantKindV1 || (TenantKindV1 = {}));
+/**
+ * @generated from protobuf enum tenant.TenantUnitTypeV1
+ */
+export var TenantUnitTypeV1;
+(function (TenantUnitTypeV1) {
+    /**
+     * @generated synthetic value - protobuf-ts requires all enums to have a 0 value
+     */
+    TenantUnitTypeV1[TenantUnitTypeV1["UNSPECIFIED$"] = 0] = "UNSPECIFIED$";
+    /**
+     * @generated from protobuf enum value: AOO = 1;
+     */
+    TenantUnitTypeV1[TenantUnitTypeV1["AOO"] = 1] = "AOO";
+    /**
+     * @generated from protobuf enum value: UO = 2;
+     */
+    TenantUnitTypeV1[TenantUnitTypeV1["UO"] = 2] = "UO";
+})(TenantUnitTypeV1 || (TenantUnitTypeV1 = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantV1$Type extends MessageType {
+    constructor() {
+        super("tenant.TenantV1", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "selfcareId", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "externalId", kind: "message", T: () => ExternalIdV1 },
+            { no: 4, name: "features", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TenantFeatureV1 },
+            { no: 5, name: "attributes", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TenantAttributeV1 },
+            { 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", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 9, name: "kind", kind: "enum", opt: true, T: () => ["tenant.TenantKindV1", TenantKindV1] },
+            { no: 10, name: "onboardedAt", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 11, name: "subUnitType", kind: "enum", opt: true, T: () => ["tenant.TenantUnitTypeV1", TenantUnitTypeV1] }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.features = [];
+        message.attributes = [];
+        message.createdAt = 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 /* optional string selfcareId */ 2:
+                    message.selfcareId = reader.string();
+                    break;
+                case /* tenant.ExternalIdV1 externalId */ 3:
+                    message.externalId = ExternalIdV1.internalBinaryRead(reader, reader.uint32(), options, message.externalId);
+                    break;
+                case /* repeated tenant.TenantFeatureV1 features */ 4:
+                    message.features.push(TenantFeatureV1.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated tenant.TenantAttributeV1 attributes */ 5:
+                    message.attributes.push(TenantAttributeV1.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 /* optional string name */ 8:
+                    message.name = reader.string();
+                    break;
+                case /* optional tenant.TenantKindV1 kind */ 9:
+                    message.kind = reader.int32();
+                    break;
+                case /* optional int64 onboardedAt */ 10:
+                    message.onboardedAt = reader.int64().toBigInt();
+                    break;
+                case /* optional tenant.TenantUnitTypeV1 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);
+        /* optional string selfcareId = 2; */
+        if (message.selfcareId !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.selfcareId);
+        /* tenant.ExternalIdV1 externalId = 3; */
+        if (message.externalId)
+            ExternalIdV1.internalBinaryWrite(message.externalId, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated tenant.TenantFeatureV1 features = 4; */
+        for (let i = 0; i < message.features.length; i++)
+            TenantFeatureV1.internalBinaryWrite(message.features[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* repeated tenant.TenantAttributeV1 attributes = 5; */
+        for (let i = 0; i < message.attributes.length; i++)
+            TenantAttributeV1.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);
+        /* optional string name = 8; */
+        if (message.name !== undefined)
+            writer.tag(8, WireType.LengthDelimited).string(message.name);
+        /* optional tenant.TenantKindV1 kind = 9; */
+        if (message.kind !== undefined)
+            writer.tag(9, WireType.Varint).int32(message.kind);
+        /* optional int64 onboardedAt = 10; */
+        if (message.onboardedAt !== undefined)
+            writer.tag(10, WireType.Varint).int64(message.onboardedAt);
+        /* optional tenant.TenantUnitTypeV1 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.TenantV1
+ */
+export const TenantV1 = new TenantV1$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantFeatureV1$Type extends MessageType {
+    constructor() {
+        super("tenant.TenantFeatureV1", [
+            { no: 1, name: "certifier", kind: "message", oneof: "sealedValue", T: () => CertifierV1 }
+        ]);
+    }
+    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.CertifierV1 certifier */ 1:
+                    message.sealedValue = {
+                        oneofKind: "certifier",
+                        certifier: CertifierV1.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.CertifierV1 certifier = 1; */
+        if (message.sealedValue.oneofKind === "certifier")
+            CertifierV1.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.TenantFeatureV1
+ */
+export const TenantFeatureV1 = new TenantFeatureV1$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CertifierV1$Type extends MessageType {
+    constructor() {
+        super("tenant.CertifierV1", [
+            { 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.CertifierV1
+ */
+export const CertifierV1 = new CertifierV1$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantVerifierV1$Type extends MessageType {
+    constructor() {
+        super("tenant.TenantVerifierV1", [
+            { 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: 4, name: "expirationDate", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 5, 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 */ 4:
+                    message.expirationDate = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 extensionDate */ 5:
+                    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 = 4; */
+        if (message.expirationDate !== undefined)
+            writer.tag(4, WireType.Varint).int64(message.expirationDate);
+        /* optional int64 extensionDate = 5; */
+        if (message.extensionDate !== undefined)
+            writer.tag(5, 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.TenantVerifierV1
+ */
+export const TenantVerifierV1 = new TenantVerifierV1$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantRevokerV1$Type extends MessageType {
+    constructor() {
+        super("tenant.TenantRevokerV1", [
+            { 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: 4, name: "expirationDate", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 5, name: "extensionDate", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 6, 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 */ 4:
+                    message.expirationDate = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 extensionDate */ 5:
+                    message.extensionDate = reader.int64().toBigInt();
+                    break;
+                case /* int64 revocationDate */ 6:
+                    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 = 4; */
+        if (message.expirationDate !== undefined)
+            writer.tag(4, WireType.Varint).int64(message.expirationDate);
+        /* optional int64 extensionDate = 5; */
+        if (message.extensionDate !== undefined)
+            writer.tag(5, WireType.Varint).int64(message.extensionDate);
+        /* int64 revocationDate = 6; */
+        if (message.revocationDate !== 0n)
+            writer.tag(6, 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.TenantRevokerV1
+ */
+export const TenantRevokerV1 = new TenantRevokerV1$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExternalIdV1$Type extends MessageType {
+    constructor() {
+        super("tenant.ExternalIdV1", [
+            { 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.ExternalIdV1
+ */
+export const ExternalIdV1 = new ExternalIdV1$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantCertifiedAttributeV1$Type extends MessageType {
+    constructor() {
+        super("tenant.TenantCertifiedAttributeV1", [
+            { 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.TenantCertifiedAttributeV1
+ */
+export const TenantCertifiedAttributeV1 = new TenantCertifiedAttributeV1$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantDeclaredAttributeV1$Type extends MessageType {
+    constructor() {
+        super("tenant.TenantDeclaredAttributeV1", [
+            { 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.TenantDeclaredAttributeV1
+ */
+export const TenantDeclaredAttributeV1 = new TenantDeclaredAttributeV1$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantVerifiedAttributeV1$Type extends MessageType {
+    constructor() {
+        super("tenant.TenantVerifiedAttributeV1", [
+            { 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: 2 /*RepeatType.UNPACKED*/, T: () => TenantVerifierV1 },
+            { no: 4, name: "revokedBy", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TenantRevokerV1 }
+        ]);
+    }
+    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.TenantVerifierV1 verifiedBy */ 3:
+                    message.verifiedBy.push(TenantVerifierV1.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated tenant.TenantRevokerV1 revokedBy */ 4:
+                    message.revokedBy.push(TenantRevokerV1.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.TenantVerifierV1 verifiedBy = 3; */
+        for (let i = 0; i < message.verifiedBy.length; i++)
+            TenantVerifierV1.internalBinaryWrite(message.verifiedBy[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated tenant.TenantRevokerV1 revokedBy = 4; */
+        for (let i = 0; i < message.revokedBy.length; i++)
+            TenantRevokerV1.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.TenantVerifiedAttributeV1
+ */
+export const TenantVerifiedAttributeV1 = new TenantVerifiedAttributeV1$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TenantAttributeV1$Type extends MessageType {
+    constructor() {
+        super("tenant.TenantAttributeV1", [
+            { no: 1, name: "certifiedAttribute", kind: "message", oneof: "sealedValue", T: () => TenantCertifiedAttributeV1 },
+            { no: 2, name: "declaredAttribute", kind: "message", oneof: "sealedValue", T: () => TenantDeclaredAttributeV1 },
+            { no: 3, name: "verifiedAttribute", kind: "message", oneof: "sealedValue", T: () => TenantVerifiedAttributeV1 }
+        ]);
+    }
+    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.TenantCertifiedAttributeV1 certifiedAttribute */ 1:
+                    message.sealedValue = {
+                        oneofKind: "certifiedAttribute",
+                        certifiedAttribute: TenantCertifiedAttributeV1.internalBinaryRead(reader, reader.uint32(), options, message.sealedValue.certifiedAttribute)
+                    };
+                    break;
+                case /* tenant.TenantDeclaredAttributeV1 declaredAttribute */ 2:
+                    message.sealedValue = {
+                        oneofKind: "declaredAttribute",
+                        declaredAttribute: TenantDeclaredAttributeV1.internalBinaryRead(reader, reader.uint32(), options, message.sealedValue.declaredAttribute)
+                    };
+                    break;
+                case /* tenant.TenantVerifiedAttributeV1 verifiedAttribute */ 3:
+                    message.sealedValue = {
+                        oneofKind: "verifiedAttribute",
+                        verifiedAttribute: TenantVerifiedAttributeV1.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.TenantCertifiedAttributeV1 certifiedAttribute = 1; */
+        if (message.sealedValue.oneofKind === "certifiedAttribute")
+            TenantCertifiedAttributeV1.internalBinaryWrite(message.sealedValue.certifiedAttribute, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* tenant.TenantDeclaredAttributeV1 declaredAttribute = 2; */
+        if (message.sealedValue.oneofKind === "declaredAttribute")
+            TenantDeclaredAttributeV1.internalBinaryWrite(message.sealedValue.declaredAttribute, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* tenant.TenantVerifiedAttributeV1 verifiedAttribute = 3; */
+        if (message.sealedValue.oneofKind === "verifiedAttribute")
+            TenantVerifiedAttributeV1.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.TenantAttributeV1
+ */
+export const TenantAttributeV1 = new TenantAttributeV1$Type();