@structured-id/ui-core 1.2.0 → 2.0.0

package/src/generated/sid/v1/authn/password_history.client.ts

@@ -0,0 +1,57 @@
+// @generated by protobuf-ts 2.11.1 with parameter client_generic,generate_dependencies
+// @generated from protobuf file "sid/v1/authn/password_history.proto" (package "sid.v1.authn", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { PasswordHistoryEvaluatorService } from "./password_history";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { EvaluatePasswordHistoryResponse } from "./password_history";
+import type { EvaluatePasswordHistoryRequest } from "./password_history";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * The VOPRF evaluator of password history. Deployed with its own service
+ * identity and key access, separate from the credential service that runs the
+ * history checker.
+ *
+ * @generated from protobuf service sid.v1.authn.PasswordHistoryEvaluatorService
+ */
+export interface IPasswordHistoryEvaluatorServiceClient {
+    /**
+     * Evaluate the blinded history input of a pending password operation under
+     * every history key the operation requires, in one bounded request. The
+     * operation, not the caller, decides which keys; the work is charged to the
+     * operation and its owner before any key is used, and an exact retry returns
+     * the same charged evaluations.
+     *
+     * @generated from protobuf rpc: EvaluatePasswordHistory
+     */
+    evaluatePasswordHistory(input: EvaluatePasswordHistoryRequest, options?: RpcOptions): UnaryCall<EvaluatePasswordHistoryRequest, EvaluatePasswordHistoryResponse>;
+}
+/**
+ * The VOPRF evaluator of password history. Deployed with its own service
+ * identity and key access, separate from the credential service that runs the
+ * history checker.
+ *
+ * @generated from protobuf service sid.v1.authn.PasswordHistoryEvaluatorService
+ */
+export class PasswordHistoryEvaluatorServiceClient implements IPasswordHistoryEvaluatorServiceClient, ServiceInfo {
+    typeName = PasswordHistoryEvaluatorService.typeName;
+    methods = PasswordHistoryEvaluatorService.methods;
+    options = PasswordHistoryEvaluatorService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * Evaluate the blinded history input of a pending password operation under
+     * every history key the operation requires, in one bounded request. The
+     * operation, not the caller, decides which keys; the work is charged to the
+     * operation and its owner before any key is used, and an exact retry returns
+     * the same charged evaluations.
+     *
+     * @generated from protobuf rpc: EvaluatePasswordHistory
+     */
+    evaluatePasswordHistory(input: EvaluatePasswordHistoryRequest, options?: RpcOptions): UnaryCall<EvaluatePasswordHistoryRequest, EvaluatePasswordHistoryResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<EvaluatePasswordHistoryRequest, EvaluatePasswordHistoryResponse>("unary", this._transport, method, opt, input);
+    }
+}

package/src/generated/sid/v1/authn/password_history.ts

@@ -0,0 +1,578 @@
+// @generated by protobuf-ts 2.11.1 with parameter client_generic,generate_dependencies
+// @generated from protobuf file "sid/v1/authn/password_history.proto" (package "sid.v1.authn", syntax proto3)
+// tslint:disable
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { PasswordOperationId } from "../ids/ids";
+/**
+ * What a client needs to build its history request and proof for one
+ * password operation. Returned by the step that prepares the operation
+ * (registration start, password-change challenge, password-reset verification).
+ *
+ * @generated from protobuf message sid.v1.authn.PasswordHistoryContext
+ */
+export interface PasswordHistoryContext {
+    /**
+     * The operation this context belongs to. Every later step of the operation
+     * (evaluation, OPAQUE start, finish) and every retry carries it. Issued by
+     * the server when it prepares the operation.
+     *
+     * @generated from protobuf field: sid.v1.ids.PasswordOperationId operation_id = 1
+     */
+    operationId?: PasswordOperationId;
+    /**
+     * The owner's history input domain: 32 bytes, a Pallas base-field element in
+     * little-endian canonical form. The client hashes the password under it into
+     * the history input it blinds. Server-derived from the credential owner;
+     * opaque to the client and unlinkable across installations and owners.
+     *
+     * @generated from protobuf field: bytes owner_domain = 2
+     */
+    ownerDomain: Uint8Array;
+    /**
+     * The comparison domains the operation must produce a tag for, in the order
+     * the evaluations and the proof's tags follow. Server-selected from the
+     * owner's retained history; at least one. The client cannot omit or reorder
+     * one: the proof commits to this list.
+     *
+     * @generated from protobuf field: repeated sid.v1.authn.PasswordHistoryDomain domains = 3
+     */
+    domains: PasswordHistoryDomain[];
+    /**
+     * Password policy version the registration proof must be made for; the
+     * verifying key of that version and domain count checks it.
+     *
+     * @generated from protobuf field: uint32 policy_version = 4
+     */
+    policyVersion: number;
+}
+/**
+ * One comparison domain: the epoch, key and format under which a tag is
+ * compared with the entries retained in it.
+ *
+ * @generated from protobuf message sid.v1.authn.PasswordHistoryDomain
+ */
+export interface PasswordHistoryDomain {
+    /**
+     * The domain element: 32 bytes, a Pallas base-field element in little-endian
+     * canonical form. Enters the tag derivation, so tags of different domains
+     * never compare equal.
+     *
+     * @generated from protobuf field: bytes comparison_domain = 1
+     */
+    comparisonDomain: Uint8Array;
+    /**
+     * The evaluator's public key for this domain, k·G: a compressed Pallas point,
+     * 32 bytes. The client checks each evaluation proof against it before
+     * proving, so a wrong or missing key fails before the costly proof.
+     *
+     * @generated from protobuf field: bytes evaluator_public_key = 2
+     */
+    evaluatorPublicKey: Uint8Array;
+}
+/**
+ * @generated from protobuf message sid.v1.authn.EvaluatePasswordHistoryRequest
+ */
+export interface EvaluatePasswordHistoryRequest {
+    /**
+     * The operation whose required domains are evaluated (from PasswordHistoryContext).
+     *
+     * @generated from protobuf field: sid.v1.ids.PasswordOperationId operation_id = 1
+     */
+    operationId?: PasswordOperationId;
+    /**
+     * The blinded history input B = r·H(u): a compressed Pallas point, 32 bytes,
+     * not the identity. Client-computed from the password under the operation's
+     * owner domain with a fresh nonzero blind r; reveals nothing about the password.
+     *
+     * @generated from protobuf field: bytes blinded_input = 2
+     */
+    blindedInput: Uint8Array;
+}
+/**
+ * @generated from protobuf message sid.v1.authn.EvaluatePasswordHistoryResponse
+ */
+export interface EvaluatePasswordHistoryResponse {
+    /**
+     * One evaluation per required comparison domain, in the order of
+     * PasswordHistoryContext.domains. Either all are present or the call fails.
+     *
+     * @generated from protobuf field: repeated sid.v1.authn.PasswordHistoryEvaluation evaluations = 1
+     */
+    evaluations: PasswordHistoryEvaluation[];
+}
+/**
+ * The evaluator's answer for one comparison domain.
+ *
+ * @generated from protobuf message sid.v1.authn.PasswordHistoryEvaluation
+ */
+export interface PasswordHistoryEvaluation {
+    /**
+     * Z = k·B under this domain's key: a compressed Pallas point, 32 bytes.
+     *
+     * @generated from protobuf field: bytes evaluated_element = 1
+     */
+    evaluatedElement: Uint8Array;
+    /**
+     * Proof that Z uses the key behind this domain's evaluator_public_key
+     * (Chaum-Pedersen DLEQ, RFC 9497 §2.2), bound to the operation.
+     *
+     * @generated from protobuf field: sid.v1.authn.PasswordHistoryEvaluationProof proof = 2
+     */
+    proof?: PasswordHistoryEvaluationProof;
+}
+/**
+ * Chaum-Pedersen proof of log_G(pk) = log_B(Z). Each domain has its own key,
+ * so each evaluation carries its own proof.
+ *
+ * @generated from protobuf message sid.v1.authn.PasswordHistoryEvaluationProof
+ */
+export interface PasswordHistoryEvaluationProof {
+    /**
+     * Challenge c: a Pallas scalar, 32 bytes little-endian.
+     *
+     * @generated from protobuf field: bytes challenge = 1
+     */
+    challenge: Uint8Array;
+    /**
+     * Response s = nonce − c·k: a Pallas scalar, 32 bytes little-endian.
+     *
+     * @generated from protobuf field: bytes response = 2
+     */
+    response: Uint8Array;
+}
+/**
+ * A registration proof for the password being installed: its policy, breach
+ * and history relation, and that the operation's OPAQUE registration element
+ * is the blinded hash of that password. The operation ID and the registration
+ * request bytes enter the proof transcript, so it verifies for no other
+ * operation or request. Sent with the final registration record, where the
+ * history checker verifies it and commits the credential. Absent when the
+ * client cannot prove; the credential then installs policy-unverified and does
+ * not advance trusted history.
+ *
+ * @generated from protobuf message sid.v1.authn.PasswordRegistrationProof
+ */
+export interface PasswordRegistrationProof {
+    /**
+     * Halo2 proof bytes. Client-generated with the OPAQUE registration request.
+     *
+     * @generated from protobuf field: bytes zkpp_proof = 1
+     */
+    zkppProof: Uint8Array;
+    /**
+     * The proof's public instances, 32 bytes each (Pallas base field,
+     * little-endian): the OPAQUE registration element M = blind·H(P) (x, y), the
+     * owner domain, the comparison domains, the blinded history input (x, y), and
+     * per domain the evaluated element (x, y) and the tag. The server checks each
+     * against the operation and its registration request; none is accepted from
+     * the client on trust.
+     *
+     * @generated from protobuf field: repeated bytes instances = 2
+     */
+    instances: Uint8Array[];
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class PasswordHistoryContext$Type extends MessageType<PasswordHistoryContext> {
+    constructor() {
+        super("sid.v1.authn.PasswordHistoryContext", [
+            { no: 1, name: "operation_id", kind: "message", T: () => PasswordOperationId },
+            { no: 2, name: "owner_domain", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "domains", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PasswordHistoryDomain },
+            { no: 4, name: "policy_version", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+    create(value?: PartialMessage<PasswordHistoryContext>): PasswordHistoryContext {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.ownerDomain = new Uint8Array(0);
+        message.domains = [];
+        message.policyVersion = 0;
+        if (value !== undefined)
+            reflectionMergePartial<PasswordHistoryContext>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PasswordHistoryContext): PasswordHistoryContext {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sid.v1.ids.PasswordOperationId operation_id */ 1:
+                    message.operationId = PasswordOperationId.internalBinaryRead(reader, reader.uint32(), options, message.operationId);
+                    break;
+                case /* bytes owner_domain */ 2:
+                    message.ownerDomain = reader.bytes();
+                    break;
+                case /* repeated sid.v1.authn.PasswordHistoryDomain domains */ 3:
+                    message.domains.push(PasswordHistoryDomain.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* uint32 policy_version */ 4:
+                    message.policyVersion = reader.uint32();
+                    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: PasswordHistoryContext, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sid.v1.ids.PasswordOperationId operation_id = 1; */
+        if (message.operationId)
+            PasswordOperationId.internalBinaryWrite(message.operationId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* bytes owner_domain = 2; */
+        if (message.ownerDomain.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.ownerDomain);
+        /* repeated sid.v1.authn.PasswordHistoryDomain domains = 3; */
+        for (let i = 0; i < message.domains.length; i++)
+            PasswordHistoryDomain.internalBinaryWrite(message.domains[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* uint32 policy_version = 4; */
+        if (message.policyVersion !== 0)
+            writer.tag(4, WireType.Varint).uint32(message.policyVersion);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sid.v1.authn.PasswordHistoryContext
+ */
+export const PasswordHistoryContext = new PasswordHistoryContext$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PasswordHistoryDomain$Type extends MessageType<PasswordHistoryDomain> {
+    constructor() {
+        super("sid.v1.authn.PasswordHistoryDomain", [
+            { no: 1, name: "comparison_domain", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "evaluator_public_key", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<PasswordHistoryDomain>): PasswordHistoryDomain {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.comparisonDomain = new Uint8Array(0);
+        message.evaluatorPublicKey = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial<PasswordHistoryDomain>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PasswordHistoryDomain): PasswordHistoryDomain {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes comparison_domain */ 1:
+                    message.comparisonDomain = reader.bytes();
+                    break;
+                case /* bytes evaluator_public_key */ 2:
+                    message.evaluatorPublicKey = reader.bytes();
+                    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: PasswordHistoryDomain, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bytes comparison_domain = 1; */
+        if (message.comparisonDomain.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.comparisonDomain);
+        /* bytes evaluator_public_key = 2; */
+        if (message.evaluatorPublicKey.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.evaluatorPublicKey);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sid.v1.authn.PasswordHistoryDomain
+ */
+export const PasswordHistoryDomain = new PasswordHistoryDomain$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EvaluatePasswordHistoryRequest$Type extends MessageType<EvaluatePasswordHistoryRequest> {
+    constructor() {
+        super("sid.v1.authn.EvaluatePasswordHistoryRequest", [
+            { no: 1, name: "operation_id", kind: "message", T: () => PasswordOperationId },
+            { no: 2, name: "blinded_input", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<EvaluatePasswordHistoryRequest>): EvaluatePasswordHistoryRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.blindedInput = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial<EvaluatePasswordHistoryRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EvaluatePasswordHistoryRequest): EvaluatePasswordHistoryRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sid.v1.ids.PasswordOperationId operation_id */ 1:
+                    message.operationId = PasswordOperationId.internalBinaryRead(reader, reader.uint32(), options, message.operationId);
+                    break;
+                case /* bytes blinded_input */ 2:
+                    message.blindedInput = reader.bytes();
+                    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: EvaluatePasswordHistoryRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sid.v1.ids.PasswordOperationId operation_id = 1; */
+        if (message.operationId)
+            PasswordOperationId.internalBinaryWrite(message.operationId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* bytes blinded_input = 2; */
+        if (message.blindedInput.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.blindedInput);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sid.v1.authn.EvaluatePasswordHistoryRequest
+ */
+export const EvaluatePasswordHistoryRequest = new EvaluatePasswordHistoryRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EvaluatePasswordHistoryResponse$Type extends MessageType<EvaluatePasswordHistoryResponse> {
+    constructor() {
+        super("sid.v1.authn.EvaluatePasswordHistoryResponse", [
+            { no: 1, name: "evaluations", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PasswordHistoryEvaluation }
+        ]);
+    }
+    create(value?: PartialMessage<EvaluatePasswordHistoryResponse>): EvaluatePasswordHistoryResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.evaluations = [];
+        if (value !== undefined)
+            reflectionMergePartial<EvaluatePasswordHistoryResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EvaluatePasswordHistoryResponse): EvaluatePasswordHistoryResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated sid.v1.authn.PasswordHistoryEvaluation evaluations */ 1:
+                    message.evaluations.push(PasswordHistoryEvaluation.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: EvaluatePasswordHistoryResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated sid.v1.authn.PasswordHistoryEvaluation evaluations = 1; */
+        for (let i = 0; i < message.evaluations.length; i++)
+            PasswordHistoryEvaluation.internalBinaryWrite(message.evaluations[i], 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 sid.v1.authn.EvaluatePasswordHistoryResponse
+ */
+export const EvaluatePasswordHistoryResponse = new EvaluatePasswordHistoryResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PasswordHistoryEvaluation$Type extends MessageType<PasswordHistoryEvaluation> {
+    constructor() {
+        super("sid.v1.authn.PasswordHistoryEvaluation", [
+            { no: 1, name: "evaluated_element", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "proof", kind: "message", T: () => PasswordHistoryEvaluationProof }
+        ]);
+    }
+    create(value?: PartialMessage<PasswordHistoryEvaluation>): PasswordHistoryEvaluation {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.evaluatedElement = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial<PasswordHistoryEvaluation>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PasswordHistoryEvaluation): PasswordHistoryEvaluation {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes evaluated_element */ 1:
+                    message.evaluatedElement = reader.bytes();
+                    break;
+                case /* sid.v1.authn.PasswordHistoryEvaluationProof proof */ 2:
+                    message.proof = PasswordHistoryEvaluationProof.internalBinaryRead(reader, reader.uint32(), options, message.proof);
+                    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: PasswordHistoryEvaluation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bytes evaluated_element = 1; */
+        if (message.evaluatedElement.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.evaluatedElement);
+        /* sid.v1.authn.PasswordHistoryEvaluationProof proof = 2; */
+        if (message.proof)
+            PasswordHistoryEvaluationProof.internalBinaryWrite(message.proof, writer.tag(2, 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 sid.v1.authn.PasswordHistoryEvaluation
+ */
+export const PasswordHistoryEvaluation = new PasswordHistoryEvaluation$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PasswordHistoryEvaluationProof$Type extends MessageType<PasswordHistoryEvaluationProof> {
+    constructor() {
+        super("sid.v1.authn.PasswordHistoryEvaluationProof", [
+            { no: 1, name: "challenge", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "response", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<PasswordHistoryEvaluationProof>): PasswordHistoryEvaluationProof {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.challenge = new Uint8Array(0);
+        message.response = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial<PasswordHistoryEvaluationProof>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PasswordHistoryEvaluationProof): PasswordHistoryEvaluationProof {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes challenge */ 1:
+                    message.challenge = reader.bytes();
+                    break;
+                case /* bytes response */ 2:
+                    message.response = reader.bytes();
+                    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: PasswordHistoryEvaluationProof, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bytes challenge = 1; */
+        if (message.challenge.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.challenge);
+        /* bytes response = 2; */
+        if (message.response.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.response);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sid.v1.authn.PasswordHistoryEvaluationProof
+ */
+export const PasswordHistoryEvaluationProof = new PasswordHistoryEvaluationProof$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PasswordRegistrationProof$Type extends MessageType<PasswordRegistrationProof> {
+    constructor() {
+        super("sid.v1.authn.PasswordRegistrationProof", [
+            { no: 1, name: "zkpp_proof", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "instances", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<PasswordRegistrationProof>): PasswordRegistrationProof {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.zkppProof = new Uint8Array(0);
+        message.instances = [];
+        if (value !== undefined)
+            reflectionMergePartial<PasswordRegistrationProof>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PasswordRegistrationProof): PasswordRegistrationProof {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes zkpp_proof */ 1:
+                    message.zkppProof = reader.bytes();
+                    break;
+                case /* repeated bytes instances */ 2:
+                    message.instances.push(reader.bytes());
+                    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: PasswordRegistrationProof, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bytes zkpp_proof = 1; */
+        if (message.zkppProof.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.zkppProof);
+        /* repeated bytes instances = 2; */
+        for (let i = 0; i < message.instances.length; i++)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.instances[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sid.v1.authn.PasswordRegistrationProof
+ */
+export const PasswordRegistrationProof = new PasswordRegistrationProof$Type();
+/**
+ * @generated ServiceType for protobuf service sid.v1.authn.PasswordHistoryEvaluatorService
+ */
+export const PasswordHistoryEvaluatorService = new ServiceType("sid.v1.authn.PasswordHistoryEvaluatorService", [
+    { name: "EvaluatePasswordHistory", idempotency: "IDEMPOTENT", options: { "google.api.http": { post: "/v1/auth/password-history/evaluate", body: "*" } }, I: EvaluatePasswordHistoryRequest, O: EvaluatePasswordHistoryResponse }
+]);