@pagopa/interop-outbound-models 1.7.2 → 1.8.0

package/dist/gen/v2/purpose-template/purpose-template.js

@@ -0,0 +1,566 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { TenantKindV2 } from "../tenant/tenant.js";
+/**
+ * @generated from protobuf enum purpose.template.v2.PurposeTemplateStateV2
+ */
+export var PurposeTemplateStateV2;
+(function (PurposeTemplateStateV2) {
+    /**
+     * @generated from protobuf enum value: DRAFT = 0;
+     */
+    PurposeTemplateStateV2[PurposeTemplateStateV2["DRAFT"] = 0] = "DRAFT";
+    /**
+     * @generated from protobuf enum value: PUBLISHED = 1;
+     */
+    PurposeTemplateStateV2[PurposeTemplateStateV2["PUBLISHED"] = 1] = "PUBLISHED";
+    /**
+     * @generated from protobuf enum value: SUSPENDED = 2;
+     */
+    PurposeTemplateStateV2[PurposeTemplateStateV2["SUSPENDED"] = 2] = "SUSPENDED";
+    /**
+     * @generated from protobuf enum value: ARCHIVED = 3;
+     */
+    PurposeTemplateStateV2[PurposeTemplateStateV2["ARCHIVED"] = 3] = "ARCHIVED";
+})(PurposeTemplateStateV2 || (PurposeTemplateStateV2 = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class PurposeTemplateV2$Type extends MessageType {
+    constructor() {
+        super("purpose.template.v2.PurposeTemplateV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "targetDescription", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "targetTenantKind", kind: "enum", T: () => ["tenant.v2.TenantKindV2", TenantKindV2] },
+            { no: 4, name: "creatorId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "state", kind: "enum", T: () => ["purpose.template.v2.PurposeTemplateStateV2", PurposeTemplateStateV2] },
+            { 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: "purposeTitle", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 9, name: "purposeDescription", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 10, name: "purposeRiskAnalysisForm", kind: "message", T: () => RiskAnalysisFormTemplateV2 },
+            { no: 11, name: "purposeIsFreeOfCharge", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 12, name: "purposeFreeOfChargeReason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 13, name: "purposeDailyCalls", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
+            { no: 14, name: "handlesPersonalData", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.targetDescription = "";
+        message.targetTenantKind = 0;
+        message.creatorId = "";
+        message.state = 0;
+        message.createdAt = 0n;
+        message.purposeTitle = "";
+        message.purposeDescription = "";
+        message.purposeIsFreeOfCharge = false;
+        message.handlesPersonalData = false;
+        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 targetDescription */ 2:
+                    message.targetDescription = reader.string();
+                    break;
+                case /* tenant.v2.TenantKindV2 targetTenantKind */ 3:
+                    message.targetTenantKind = reader.int32();
+                    break;
+                case /* string creatorId */ 4:
+                    message.creatorId = reader.string();
+                    break;
+                case /* purpose.template.v2.PurposeTemplateStateV2 state */ 5:
+                    message.state = reader.int32();
+                    break;
+                case /* int64 createdAt */ 6:
+                    message.createdAt = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 updatedAt */ 7:
+                    message.updatedAt = reader.int64().toBigInt();
+                    break;
+                case /* string purposeTitle */ 8:
+                    message.purposeTitle = reader.string();
+                    break;
+                case /* string purposeDescription */ 9:
+                    message.purposeDescription = reader.string();
+                    break;
+                case /* optional purpose.template.v2.RiskAnalysisFormTemplateV2 purposeRiskAnalysisForm */ 10:
+                    message.purposeRiskAnalysisForm = RiskAnalysisFormTemplateV2.internalBinaryRead(reader, reader.uint32(), options, message.purposeRiskAnalysisForm);
+                    break;
+                case /* bool purposeIsFreeOfCharge */ 11:
+                    message.purposeIsFreeOfCharge = reader.bool();
+                    break;
+                case /* optional string purposeFreeOfChargeReason */ 12:
+                    message.purposeFreeOfChargeReason = reader.string();
+                    break;
+                case /* optional int32 purposeDailyCalls */ 13:
+                    message.purposeDailyCalls = reader.int32();
+                    break;
+                case /* bool handlesPersonalData */ 14:
+                    message.handlesPersonalData = reader.bool();
+                    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 targetDescription = 2; */
+        if (message.targetDescription !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.targetDescription);
+        /* tenant.v2.TenantKindV2 targetTenantKind = 3; */
+        if (message.targetTenantKind !== 0)
+            writer.tag(3, WireType.Varint).int32(message.targetTenantKind);
+        /* string creatorId = 4; */
+        if (message.creatorId !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.creatorId);
+        /* purpose.template.v2.PurposeTemplateStateV2 state = 5; */
+        if (message.state !== 0)
+            writer.tag(5, WireType.Varint).int32(message.state);
+        /* 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 purposeTitle = 8; */
+        if (message.purposeTitle !== "")
+            writer.tag(8, WireType.LengthDelimited).string(message.purposeTitle);
+        /* string purposeDescription = 9; */
+        if (message.purposeDescription !== "")
+            writer.tag(9, WireType.LengthDelimited).string(message.purposeDescription);
+        /* optional purpose.template.v2.RiskAnalysisFormTemplateV2 purposeRiskAnalysisForm = 10; */
+        if (message.purposeRiskAnalysisForm)
+            RiskAnalysisFormTemplateV2.internalBinaryWrite(message.purposeRiskAnalysisForm, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* bool purposeIsFreeOfCharge = 11; */
+        if (message.purposeIsFreeOfCharge !== false)
+            writer.tag(11, WireType.Varint).bool(message.purposeIsFreeOfCharge);
+        /* optional string purposeFreeOfChargeReason = 12; */
+        if (message.purposeFreeOfChargeReason !== undefined)
+            writer.tag(12, WireType.LengthDelimited).string(message.purposeFreeOfChargeReason);
+        /* optional int32 purposeDailyCalls = 13; */
+        if (message.purposeDailyCalls !== undefined)
+            writer.tag(13, WireType.Varint).int32(message.purposeDailyCalls);
+        /* bool handlesPersonalData = 14; */
+        if (message.handlesPersonalData !== false)
+            writer.tag(14, WireType.Varint).bool(message.handlesPersonalData);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message purpose.template.v2.PurposeTemplateV2
+ */
+export const PurposeTemplateV2 = new PurposeTemplateV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RiskAnalysisFormTemplateV2$Type extends MessageType {
+    constructor() {
+        super("purpose.template.v2.RiskAnalysisFormTemplateV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "singleAnswers", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => RiskAnalysisTemplateSingleAnswerV2 },
+            { no: 4, name: "multiAnswers", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => RiskAnalysisTemplateMultiAnswerV2 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.version = "";
+        message.singleAnswers = [];
+        message.multiAnswers = [];
+        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 version */ 2:
+                    message.version = reader.string();
+                    break;
+                case /* repeated purpose.template.v2.RiskAnalysisTemplateSingleAnswerV2 singleAnswers */ 3:
+                    message.singleAnswers.push(RiskAnalysisTemplateSingleAnswerV2.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated purpose.template.v2.RiskAnalysisTemplateMultiAnswerV2 multiAnswers */ 4:
+                    message.multiAnswers.push(RiskAnalysisTemplateMultiAnswerV2.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);
+        /* string version = 2; */
+        if (message.version !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.version);
+        /* repeated purpose.template.v2.RiskAnalysisTemplateSingleAnswerV2 singleAnswers = 3; */
+        for (let i = 0; i < message.singleAnswers.length; i++)
+            RiskAnalysisTemplateSingleAnswerV2.internalBinaryWrite(message.singleAnswers[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated purpose.template.v2.RiskAnalysisTemplateMultiAnswerV2 multiAnswers = 4; */
+        for (let i = 0; i < message.multiAnswers.length; i++)
+            RiskAnalysisTemplateMultiAnswerV2.internalBinaryWrite(message.multiAnswers[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 purpose.template.v2.RiskAnalysisFormTemplateV2
+ */
+export const RiskAnalysisFormTemplateV2 = new RiskAnalysisFormTemplateV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RiskAnalysisTemplateSingleAnswerV2$Type extends MessageType {
+    constructor() {
+        super("purpose.template.v2.RiskAnalysisTemplateSingleAnswerV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "value", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "editable", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "annotation", kind: "message", T: () => RiskAnalysisTemplateAnswerAnnotationV2 },
+            { no: 6, name: "suggestedValues", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.key = "";
+        message.editable = false;
+        message.suggestedValues = [];
+        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 key */ 2:
+                    message.key = reader.string();
+                    break;
+                case /* optional string value */ 3:
+                    message.value = reader.string();
+                    break;
+                case /* bool editable */ 4:
+                    message.editable = reader.bool();
+                    break;
+                case /* optional purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationV2 annotation */ 5:
+                    message.annotation = RiskAnalysisTemplateAnswerAnnotationV2.internalBinaryRead(reader, reader.uint32(), options, message.annotation);
+                    break;
+                case /* repeated string suggestedValues */ 6:
+                    message.suggestedValues.push(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 id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* string key = 2; */
+        if (message.key !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.key);
+        /* optional string value = 3; */
+        if (message.value !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.value);
+        /* bool editable = 4; */
+        if (message.editable !== false)
+            writer.tag(4, WireType.Varint).bool(message.editable);
+        /* optional purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationV2 annotation = 5; */
+        if (message.annotation)
+            RiskAnalysisTemplateAnswerAnnotationV2.internalBinaryWrite(message.annotation, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string suggestedValues = 6; */
+        for (let i = 0; i < message.suggestedValues.length; i++)
+            writer.tag(6, WireType.LengthDelimited).string(message.suggestedValues[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message purpose.template.v2.RiskAnalysisTemplateSingleAnswerV2
+ */
+export const RiskAnalysisTemplateSingleAnswerV2 = new RiskAnalysisTemplateSingleAnswerV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RiskAnalysisTemplateMultiAnswerV2$Type extends MessageType {
+    constructor() {
+        super("purpose.template.v2.RiskAnalysisTemplateMultiAnswerV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "values", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "editable", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "annotation", kind: "message", T: () => RiskAnalysisTemplateAnswerAnnotationV2 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.key = "";
+        message.values = [];
+        message.editable = false;
+        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 key */ 2:
+                    message.key = reader.string();
+                    break;
+                case /* repeated string values */ 3:
+                    message.values.push(reader.string());
+                    break;
+                case /* bool editable */ 4:
+                    message.editable = reader.bool();
+                    break;
+                case /* optional purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationV2 annotation */ 5:
+                    message.annotation = RiskAnalysisTemplateAnswerAnnotationV2.internalBinaryRead(reader, reader.uint32(), options, message.annotation);
+                    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 key = 2; */
+        if (message.key !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.key);
+        /* repeated string values = 3; */
+        for (let i = 0; i < message.values.length; i++)
+            writer.tag(3, WireType.LengthDelimited).string(message.values[i]);
+        /* bool editable = 4; */
+        if (message.editable !== false)
+            writer.tag(4, WireType.Varint).bool(message.editable);
+        /* optional purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationV2 annotation = 5; */
+        if (message.annotation)
+            RiskAnalysisTemplateAnswerAnnotationV2.internalBinaryWrite(message.annotation, writer.tag(5, 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 purpose.template.v2.RiskAnalysisTemplateMultiAnswerV2
+ */
+export const RiskAnalysisTemplateMultiAnswerV2 = new RiskAnalysisTemplateMultiAnswerV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RiskAnalysisTemplateAnswerAnnotationV2$Type extends MessageType {
+    constructor() {
+        super("purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "text", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "docs", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => RiskAnalysisTemplateAnswerAnnotationDocumentV2 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.text = "";
+        message.docs = [];
+        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 text */ 2:
+                    message.text = reader.string();
+                    break;
+                case /* repeated purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationDocumentV2 docs */ 3:
+                    message.docs.push(RiskAnalysisTemplateAnswerAnnotationDocumentV2.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);
+        /* string text = 2; */
+        if (message.text !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.text);
+        /* repeated purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationDocumentV2 docs = 3; */
+        for (let i = 0; i < message.docs.length; i++)
+            RiskAnalysisTemplateAnswerAnnotationDocumentV2.internalBinaryWrite(message.docs[i], 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 purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationV2
+ */
+export const RiskAnalysisTemplateAnswerAnnotationV2 = new RiskAnalysisTemplateAnswerAnnotationV2$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RiskAnalysisTemplateAnswerAnnotationDocumentV2$Type extends MessageType {
+    constructor() {
+        super("purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationDocumentV2", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "prettyName", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "contentType", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "path", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "createdAt", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 7, name: "checksum", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.name = "";
+        message.prettyName = "";
+        message.contentType = "";
+        message.path = "";
+        message.createdAt = 0n;
+        message.checksum = "";
+        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 name */ 2:
+                    message.name = reader.string();
+                    break;
+                case /* string prettyName */ 3:
+                    message.prettyName = reader.string();
+                    break;
+                case /* string contentType */ 4:
+                    message.contentType = reader.string();
+                    break;
+                case /* string path */ 5:
+                    message.path = reader.string();
+                    break;
+                case /* int64 createdAt */ 6:
+                    message.createdAt = reader.int64().toBigInt();
+                    break;
+                case /* string checksum */ 7:
+                    message.checksum = 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 id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* string name = 2; */
+        if (message.name !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.name);
+        /* string prettyName = 3; */
+        if (message.prettyName !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.prettyName);
+        /* string contentType = 4; */
+        if (message.contentType !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.contentType);
+        /* string path = 5; */
+        if (message.path !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.path);
+        /* int64 createdAt = 6; */
+        if (message.createdAt !== 0n)
+            writer.tag(6, WireType.Varint).int64(message.createdAt);
+        /* string checksum = 7; */
+        if (message.checksum !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.checksum);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message purpose.template.v2.RiskAnalysisTemplateAnswerAnnotationDocumentV2
+ */
+export const RiskAnalysisTemplateAnswerAnnotationDocumentV2 = new RiskAnalysisTemplateAnswerAnnotationDocumentV2$Type();