@miradorlabs/web-grpc 3.19.0 → 3.20.0

package/proto/gateway/web/v1/admin_gateway.ts

@@ -10,7 +10,7 @@ import type { Metadata } from "@grpc/grpc-js";
 import { Timestamp } from "../../../../google/protobuf/timestamp";
 import { ResponseStatus } from "../../common/v1/status";
 import { InviteCodeState, inviteCodeStateFromJSON, inviteCodeStateToJSON } from "./beta_gateway";
-import { AIReferenceName } from "./reference_gateway";
+import { AIReferenceGroupFilter, AIReferenceName } from "./reference_gateway";
 
 export const protobufPackage = "gateway.web.v1";
 
@@ -98,6 +98,78 @@ export interface UpdateAIBillerResponse {
   biller: AIReferenceName | undefined;
 }
 
+export interface ConfirmAIProvidersRequest {
+  /** As on ListAIProviderGroups: the caller's organizations of this product; any other id fails the request. */
+  organizationIds: string[];
+  /**
+   * The groups to confirm, as the list filters them; unset confirms every unreviewed name in the table. The list's
+   * counts.unreviewed_name_count under the same filter previews the count.
+   */
+  filter: AIReferenceGroupFilter | undefined;
+}
+
+export interface ConfirmAIProvidersResponse {
+  status:
+    | ResponseStatus
+    | undefined;
+  /** The names written; 0 when the filter kept nothing to confirm. */
+  confirmedNameCount: number;
+}
+
+export interface ConfirmAIModelsRequest {
+  /** As on ListAIModelGroups: the caller's organizations of this product; any other id fails the request. */
+  organizationIds: string[];
+  /**
+   * The groups to confirm, as the list filters them; unset confirms every unreviewed name in the table. The list's
+   * counts.unreviewed_name_count under the same filter previews the count.
+   */
+  filter: AIReferenceGroupFilter | undefined;
+}
+
+export interface ConfirmAIModelsResponse {
+  status:
+    | ResponseStatus
+    | undefined;
+  /** The names written; 0 when the filter kept nothing to confirm. */
+  confirmedNameCount: number;
+}
+
+export interface ConfirmAIEffortsRequest {
+  /** As on ListAIEffortGroups: the caller's organizations of this product; any other id fails the request. */
+  organizationIds: string[];
+  /**
+   * The groups to confirm, as the list filters them; unset confirms every unreviewed name in the table. The list's
+   * counts.unreviewed_name_count under the same filter previews the count.
+   */
+  filter: AIReferenceGroupFilter | undefined;
+}
+
+export interface ConfirmAIEffortsResponse {
+  status:
+    | ResponseStatus
+    | undefined;
+  /** The names written; 0 when the filter kept nothing to confirm. */
+  confirmedNameCount: number;
+}
+
+export interface ConfirmAIBillersRequest {
+  /** As on ListAIBillerGroups: the caller's organizations of this product; any other id fails the request. */
+  organizationIds: string[];
+  /**
+   * The groups to confirm, as the list filters them; unset confirms every unreviewed name in the table. The list's
+   * counts.unreviewed_name_count under the same filter previews the count.
+   */
+  filter: AIReferenceGroupFilter | undefined;
+}
+
+export interface ConfirmAIBillersResponse {
+  status:
+    | ResponseStatus
+    | undefined;
+  /** The names written; 0 when the filter kept nothing to confirm. */
+  confirmedNameCount: number;
+}
+
 function createBaseGetAdminStatusRequest(): GetAdminStatusRequest {
   return {};
 }
@@ -1507,121 +1579,900 @@ export const UpdateAIBillerResponse: MessageFns<UpdateAIBillerResponse> = {
   },
 };
 
-/**
- * AdminGatewayService is the browser-facing surface of the admin tools, across every domain, which only
- * Mirador staff (a verified mirador.org primary email) may use. The gateway's admin gate admits every RPC
- * here except GetAdminStatus, which tells the frontend whether to show the admin tools at all.
- */
-export interface AdminGatewayService {
-  /** GetAdminStatus reports whether the authenticated caller may use the admin tools. */
-  GetAdminStatus(request: GetAdminStatusRequest, metadata?: Metadata): Promise<GetAdminStatusResponse>;
-  /** Beta invite codes for this gateway's product. */
-  GenerateInviteCodes(request: GenerateInviteCodesRequest, metadata?: Metadata): Promise<GenerateInviteCodesResponse>;
-  ListInviteCodes(request: ListInviteCodesRequest, metadata?: Metadata): Promise<ListInviteCodesResponse>;
-  /**
-   * Staff set a global AI name's display name for every organization. An update makes the name MANUAL; the
-   * model processor never overwrites it. The tables are read through ReferenceGatewayService.
-   */
-  UpdateAIProvider(request: UpdateAIProviderRequest, metadata?: Metadata): Promise<UpdateAIProviderResponse>;
-  UpdateAIModel(request: UpdateAIModelRequest, metadata?: Metadata): Promise<UpdateAIModelResponse>;
-  UpdateAIEffort(request: UpdateAIEffortRequest, metadata?: Metadata): Promise<UpdateAIEffortResponse>;
-  UpdateAIBiller(request: UpdateAIBillerRequest, metadata?: Metadata): Promise<UpdateAIBillerResponse>;
+function createBaseConfirmAIProvidersRequest(): ConfirmAIProvidersRequest {
+  return { organizationIds: [], filter: undefined };
 }
 
-export const AdminGatewayServiceServiceName = "gateway.web.v1.AdminGatewayService";
-export class AdminGatewayServiceClientImpl implements AdminGatewayService {
-  private readonly rpc: Rpc;
-  private readonly service: string;
-  constructor(rpc: Rpc, opts?: { service?: string }) {
-    this.service = opts?.service || AdminGatewayServiceServiceName;
-    this.rpc = rpc;
-    this.GetAdminStatus = this.GetAdminStatus.bind(this);
-    this.GenerateInviteCodes = this.GenerateInviteCodes.bind(this);
-    this.ListInviteCodes = this.ListInviteCodes.bind(this);
-    this.UpdateAIProvider = this.UpdateAIProvider.bind(this);
-    this.UpdateAIModel = this.UpdateAIModel.bind(this);
-    this.UpdateAIEffort = this.UpdateAIEffort.bind(this);
-    this.UpdateAIBiller = this.UpdateAIBiller.bind(this);
-  }
-  GetAdminStatus(request: GetAdminStatusRequest, metadata?: Metadata): Promise<GetAdminStatusResponse> {
-    const data = GetAdminStatusRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "GetAdminStatus", data, metadata);
-    return promise.then((data) => GetAdminStatusResponse.decode(new BinaryReader(data)));
-  }
+export const ConfirmAIProvidersRequest: MessageFns<ConfirmAIProvidersRequest> = {
+  encode(message: ConfirmAIProvidersRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.organizationIds) {
+      writer.uint32(10).string(v!);
+    }
+    if (message.filter !== undefined) {
+      AIReferenceGroupFilter.encode(message.filter, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
 
-  GenerateInviteCodes(request: GenerateInviteCodesRequest, metadata?: Metadata): Promise<GenerateInviteCodesResponse> {
-    const data = GenerateInviteCodesRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "GenerateInviteCodes", data, metadata);
-    return promise.then((data) => GenerateInviteCodesResponse.decode(new BinaryReader(data)));
-  }
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfirmAIProvidersRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseConfirmAIProvidersRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
 
-  ListInviteCodes(request: ListInviteCodesRequest, metadata?: Metadata): Promise<ListInviteCodesResponse> {
-    const data = ListInviteCodesRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "ListInviteCodes", data, metadata);
-    return promise.then((data) => ListInviteCodesResponse.decode(new BinaryReader(data)));
-  }
+            message.organizationIds.push(reader.string());
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
 
-  UpdateAIProvider(request: UpdateAIProviderRequest, metadata?: Metadata): Promise<UpdateAIProviderResponse> {
-    const data = UpdateAIProviderRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "UpdateAIProvider", data, metadata);
-    return promise.then((data) => UpdateAIProviderResponse.decode(new BinaryReader(data)));
-  }
+            message.filter = AIReferenceGroupFilter.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
 
-  UpdateAIModel(request: UpdateAIModelRequest, metadata?: Metadata): Promise<UpdateAIModelResponse> {
-    const data = UpdateAIModelRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "UpdateAIModel", data, metadata);
-    return promise.then((data) => UpdateAIModelResponse.decode(new BinaryReader(data)));
-  }
+  fromJSON(object: any): ConfirmAIProvidersRequest {
+    return {
+      organizationIds: globalThis.Array.isArray(object?.organizationIds)
+        ? object.organizationIds.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.organization_ids)
+        ? object.organization_ids.map((e: any) => globalThis.String(e))
+        : [],
+      filter: isSet(object.filter) ? AIReferenceGroupFilter.fromJSON(object.filter) : undefined,
+    };
+  },
 
-  UpdateAIEffort(request: UpdateAIEffortRequest, metadata?: Metadata): Promise<UpdateAIEffortResponse> {
-    const data = UpdateAIEffortRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "UpdateAIEffort", data, metadata);
-    return promise.then((data) => UpdateAIEffortResponse.decode(new BinaryReader(data)));
-  }
+  toJSON(message: ConfirmAIProvidersRequest): unknown {
+    const obj: any = {};
+    if (message.organizationIds?.length) {
+      obj.organizationIds = message.organizationIds;
+    }
+    if (message.filter !== undefined) {
+      obj.filter = AIReferenceGroupFilter.toJSON(message.filter);
+    }
+    return obj;
+  },
 
-  UpdateAIBiller(request: UpdateAIBillerRequest, metadata?: Metadata): Promise<UpdateAIBillerResponse> {
-    const data = UpdateAIBillerRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "UpdateAIBiller", data, metadata);
-    return promise.then((data) => UpdateAIBillerResponse.decode(new BinaryReader(data)));
-  }
-}
+  create<I extends Exact<DeepPartial<ConfirmAIProvidersRequest>, I>>(base?: I): ConfirmAIProvidersRequest {
+    return ConfirmAIProvidersRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ConfirmAIProvidersRequest>, I>>(object: I): ConfirmAIProvidersRequest {
+    const message = createBaseConfirmAIProvidersRequest();
+    message.organizationIds = object.organizationIds?.map((e) => e) || [];
+    message.filter = (object.filter !== undefined && object.filter !== null)
+      ? AIReferenceGroupFilter.fromPartial(object.filter)
+      : undefined;
+    return message;
+  },
+};
 
-interface Rpc {
-  request(service: string, method: string, data: Uint8Array, metadata?: Metadata): Promise<Uint8Array>;
+function createBaseConfirmAIProvidersResponse(): ConfirmAIProvidersResponse {
+  return { status: undefined, confirmedNameCount: 0 };
 }
 
-type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export const ConfirmAIProvidersResponse: MessageFns<ConfirmAIProvidersResponse> = {
+  encode(message: ConfirmAIProvidersResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.confirmedNameCount !== 0) {
+      writer.uint32(16).int64(message.confirmedNameCount);
+    }
+    return writer;
+  },
 
-export type DeepPartial<T> = T extends Builtin ? T
-  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
-  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
-  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : Partial<T>;
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfirmAIProvidersResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseConfirmAIProvidersResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
 
-type KeysOfUnion<T> = T extends T ? keyof T : never;
-export type Exact<P, I extends P> = P extends Builtin ? P
-  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+            message.status = ResponseStatus.decode(reader, reader.uint32());
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
 
-function toTimestamp(date: Date): Timestamp {
-  const seconds = Math.trunc(date.getTime() / 1_000);
-  const nanos = (date.getTime() % 1_000) * 1_000_000;
-  return { seconds, nanos };
-}
+            message.confirmedNameCount = longToNumber(reader.int64());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
 
-function fromTimestamp(t: Timestamp): Date {
-  let millis = (t.seconds || 0) * 1_000;
-  millis += (t.nanos || 0) / 1_000_000;
-  return new globalThis.Date(millis);
+  fromJSON(object: any): ConfirmAIProvidersResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      confirmedNameCount: isSet(object.confirmedNameCount)
+        ? globalThis.Number(object.confirmedNameCount)
+        : isSet(object.confirmed_name_count)
+        ? globalThis.Number(object.confirmed_name_count)
+        : 0,
+    };
+  },
+
+  toJSON(message: ConfirmAIProvidersResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.confirmedNameCount !== 0) {
+      obj.confirmedNameCount = Math.round(message.confirmedNameCount);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ConfirmAIProvidersResponse>, I>>(base?: I): ConfirmAIProvidersResponse {
+    return ConfirmAIProvidersResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ConfirmAIProvidersResponse>, I>>(object: I): ConfirmAIProvidersResponse {
+    const message = createBaseConfirmAIProvidersResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.confirmedNameCount = object.confirmedNameCount ?? 0;
+    return message;
+  },
+};
+
+function createBaseConfirmAIModelsRequest(): ConfirmAIModelsRequest {
+  return { organizationIds: [], filter: undefined };
 }
 
-function fromJsonTimestamp(o: any): Date {
-  if (o instanceof globalThis.Date) {
-    return o;
-  } else if (typeof o === "string") {
-    return new globalThis.Date(o);
-  } else {
-    return fromTimestamp(Timestamp.fromJSON(o));
+export const ConfirmAIModelsRequest: MessageFns<ConfirmAIModelsRequest> = {
+  encode(message: ConfirmAIModelsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.organizationIds) {
+      writer.uint32(10).string(v!);
+    }
+    if (message.filter !== undefined) {
+      AIReferenceGroupFilter.encode(message.filter, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfirmAIModelsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseConfirmAIModelsRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.organizationIds.push(reader.string());
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.filter = AIReferenceGroupFilter.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ConfirmAIModelsRequest {
+    return {
+      organizationIds: globalThis.Array.isArray(object?.organizationIds)
+        ? object.organizationIds.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.organization_ids)
+        ? object.organization_ids.map((e: any) => globalThis.String(e))
+        : [],
+      filter: isSet(object.filter) ? AIReferenceGroupFilter.fromJSON(object.filter) : undefined,
+    };
+  },
+
+  toJSON(message: ConfirmAIModelsRequest): unknown {
+    const obj: any = {};
+    if (message.organizationIds?.length) {
+      obj.organizationIds = message.organizationIds;
+    }
+    if (message.filter !== undefined) {
+      obj.filter = AIReferenceGroupFilter.toJSON(message.filter);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ConfirmAIModelsRequest>, I>>(base?: I): ConfirmAIModelsRequest {
+    return ConfirmAIModelsRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ConfirmAIModelsRequest>, I>>(object: I): ConfirmAIModelsRequest {
+    const message = createBaseConfirmAIModelsRequest();
+    message.organizationIds = object.organizationIds?.map((e) => e) || [];
+    message.filter = (object.filter !== undefined && object.filter !== null)
+      ? AIReferenceGroupFilter.fromPartial(object.filter)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseConfirmAIModelsResponse(): ConfirmAIModelsResponse {
+  return { status: undefined, confirmedNameCount: 0 };
+}
+
+export const ConfirmAIModelsResponse: MessageFns<ConfirmAIModelsResponse> = {
+  encode(message: ConfirmAIModelsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.confirmedNameCount !== 0) {
+      writer.uint32(16).int64(message.confirmedNameCount);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfirmAIModelsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseConfirmAIModelsResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.status = ResponseStatus.decode(reader, reader.uint32());
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.confirmedNameCount = longToNumber(reader.int64());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ConfirmAIModelsResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      confirmedNameCount: isSet(object.confirmedNameCount)
+        ? globalThis.Number(object.confirmedNameCount)
+        : isSet(object.confirmed_name_count)
+        ? globalThis.Number(object.confirmed_name_count)
+        : 0,
+    };
+  },
+
+  toJSON(message: ConfirmAIModelsResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.confirmedNameCount !== 0) {
+      obj.confirmedNameCount = Math.round(message.confirmedNameCount);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ConfirmAIModelsResponse>, I>>(base?: I): ConfirmAIModelsResponse {
+    return ConfirmAIModelsResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ConfirmAIModelsResponse>, I>>(object: I): ConfirmAIModelsResponse {
+    const message = createBaseConfirmAIModelsResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.confirmedNameCount = object.confirmedNameCount ?? 0;
+    return message;
+  },
+};
+
+function createBaseConfirmAIEffortsRequest(): ConfirmAIEffortsRequest {
+  return { organizationIds: [], filter: undefined };
+}
+
+export const ConfirmAIEffortsRequest: MessageFns<ConfirmAIEffortsRequest> = {
+  encode(message: ConfirmAIEffortsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.organizationIds) {
+      writer.uint32(10).string(v!);
+    }
+    if (message.filter !== undefined) {
+      AIReferenceGroupFilter.encode(message.filter, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfirmAIEffortsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseConfirmAIEffortsRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.organizationIds.push(reader.string());
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.filter = AIReferenceGroupFilter.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ConfirmAIEffortsRequest {
+    return {
+      organizationIds: globalThis.Array.isArray(object?.organizationIds)
+        ? object.organizationIds.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.organization_ids)
+        ? object.organization_ids.map((e: any) => globalThis.String(e))
+        : [],
+      filter: isSet(object.filter) ? AIReferenceGroupFilter.fromJSON(object.filter) : undefined,
+    };
+  },
+
+  toJSON(message: ConfirmAIEffortsRequest): unknown {
+    const obj: any = {};
+    if (message.organizationIds?.length) {
+      obj.organizationIds = message.organizationIds;
+    }
+    if (message.filter !== undefined) {
+      obj.filter = AIReferenceGroupFilter.toJSON(message.filter);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ConfirmAIEffortsRequest>, I>>(base?: I): ConfirmAIEffortsRequest {
+    return ConfirmAIEffortsRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ConfirmAIEffortsRequest>, I>>(object: I): ConfirmAIEffortsRequest {
+    const message = createBaseConfirmAIEffortsRequest();
+    message.organizationIds = object.organizationIds?.map((e) => e) || [];
+    message.filter = (object.filter !== undefined && object.filter !== null)
+      ? AIReferenceGroupFilter.fromPartial(object.filter)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseConfirmAIEffortsResponse(): ConfirmAIEffortsResponse {
+  return { status: undefined, confirmedNameCount: 0 };
+}
+
+export const ConfirmAIEffortsResponse: MessageFns<ConfirmAIEffortsResponse> = {
+  encode(message: ConfirmAIEffortsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.confirmedNameCount !== 0) {
+      writer.uint32(16).int64(message.confirmedNameCount);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfirmAIEffortsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseConfirmAIEffortsResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.status = ResponseStatus.decode(reader, reader.uint32());
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.confirmedNameCount = longToNumber(reader.int64());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ConfirmAIEffortsResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      confirmedNameCount: isSet(object.confirmedNameCount)
+        ? globalThis.Number(object.confirmedNameCount)
+        : isSet(object.confirmed_name_count)
+        ? globalThis.Number(object.confirmed_name_count)
+        : 0,
+    };
+  },
+
+  toJSON(message: ConfirmAIEffortsResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.confirmedNameCount !== 0) {
+      obj.confirmedNameCount = Math.round(message.confirmedNameCount);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ConfirmAIEffortsResponse>, I>>(base?: I): ConfirmAIEffortsResponse {
+    return ConfirmAIEffortsResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ConfirmAIEffortsResponse>, I>>(object: I): ConfirmAIEffortsResponse {
+    const message = createBaseConfirmAIEffortsResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.confirmedNameCount = object.confirmedNameCount ?? 0;
+    return message;
+  },
+};
+
+function createBaseConfirmAIBillersRequest(): ConfirmAIBillersRequest {
+  return { organizationIds: [], filter: undefined };
+}
+
+export const ConfirmAIBillersRequest: MessageFns<ConfirmAIBillersRequest> = {
+  encode(message: ConfirmAIBillersRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.organizationIds) {
+      writer.uint32(10).string(v!);
+    }
+    if (message.filter !== undefined) {
+      AIReferenceGroupFilter.encode(message.filter, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfirmAIBillersRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseConfirmAIBillersRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.organizationIds.push(reader.string());
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.filter = AIReferenceGroupFilter.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ConfirmAIBillersRequest {
+    return {
+      organizationIds: globalThis.Array.isArray(object?.organizationIds)
+        ? object.organizationIds.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.organization_ids)
+        ? object.organization_ids.map((e: any) => globalThis.String(e))
+        : [],
+      filter: isSet(object.filter) ? AIReferenceGroupFilter.fromJSON(object.filter) : undefined,
+    };
+  },
+
+  toJSON(message: ConfirmAIBillersRequest): unknown {
+    const obj: any = {};
+    if (message.organizationIds?.length) {
+      obj.organizationIds = message.organizationIds;
+    }
+    if (message.filter !== undefined) {
+      obj.filter = AIReferenceGroupFilter.toJSON(message.filter);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ConfirmAIBillersRequest>, I>>(base?: I): ConfirmAIBillersRequest {
+    return ConfirmAIBillersRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ConfirmAIBillersRequest>, I>>(object: I): ConfirmAIBillersRequest {
+    const message = createBaseConfirmAIBillersRequest();
+    message.organizationIds = object.organizationIds?.map((e) => e) || [];
+    message.filter = (object.filter !== undefined && object.filter !== null)
+      ? AIReferenceGroupFilter.fromPartial(object.filter)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseConfirmAIBillersResponse(): ConfirmAIBillersResponse {
+  return { status: undefined, confirmedNameCount: 0 };
+}
+
+export const ConfirmAIBillersResponse: MessageFns<ConfirmAIBillersResponse> = {
+  encode(message: ConfirmAIBillersResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.confirmedNameCount !== 0) {
+      writer.uint32(16).int64(message.confirmedNameCount);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfirmAIBillersResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseConfirmAIBillersResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.status = ResponseStatus.decode(reader, reader.uint32());
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.confirmedNameCount = longToNumber(reader.int64());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ConfirmAIBillersResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      confirmedNameCount: isSet(object.confirmedNameCount)
+        ? globalThis.Number(object.confirmedNameCount)
+        : isSet(object.confirmed_name_count)
+        ? globalThis.Number(object.confirmed_name_count)
+        : 0,
+    };
+  },
+
+  toJSON(message: ConfirmAIBillersResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.confirmedNameCount !== 0) {
+      obj.confirmedNameCount = Math.round(message.confirmedNameCount);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ConfirmAIBillersResponse>, I>>(base?: I): ConfirmAIBillersResponse {
+    return ConfirmAIBillersResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ConfirmAIBillersResponse>, I>>(object: I): ConfirmAIBillersResponse {
+    const message = createBaseConfirmAIBillersResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.confirmedNameCount = object.confirmedNameCount ?? 0;
+    return message;
+  },
+};
+
+/**
+ * AdminGatewayService is the browser-facing surface of the admin tools, across every domain, which only
+ * Mirador staff (a verified mirador.org primary email) may use. The gateway's admin gate admits every RPC
+ * here except GetAdminStatus, which tells the frontend whether to show the admin tools at all.
+ */
+export interface AdminGatewayService {
+  /** GetAdminStatus reports whether the authenticated caller may use the admin tools. */
+  GetAdminStatus(request: GetAdminStatusRequest, metadata?: Metadata): Promise<GetAdminStatusResponse>;
+  /** Beta invite codes for this gateway's product. */
+  GenerateInviteCodes(request: GenerateInviteCodesRequest, metadata?: Metadata): Promise<GenerateInviteCodesResponse>;
+  ListInviteCodes(request: ListInviteCodesRequest, metadata?: Metadata): Promise<ListInviteCodesResponse>;
+  /**
+   * Staff set a global AI name's display name for every organization. An update makes the name MANUAL; the
+   * model processor never overwrites it. The tables are read through ReferenceGatewayService.
+   */
+  UpdateAIProvider(request: UpdateAIProviderRequest, metadata?: Metadata): Promise<UpdateAIProviderResponse>;
+  UpdateAIModel(request: UpdateAIModelRequest, metadata?: Metadata): Promise<UpdateAIModelResponse>;
+  UpdateAIEffort(request: UpdateAIEffortRequest, metadata?: Metadata): Promise<UpdateAIEffortResponse>;
+  UpdateAIBiller(request: UpdateAIBillerRequest, metadata?: Metadata): Promise<UpdateAIBillerResponse>;
+  /**
+   * Each Confirm<X> confirms every unreviewed name in the groups a List<X>Groups filter keeps (on every page),
+   * as one Update<X> per name would; it proxies telemetry.api.v1.TelemetryAdminService's Confirm<X>. It
+   * confirms what matches when it runs: compare confirmed_name_count with the count shown. Names are global: an
+   * unset observation also confirms groups none of the organizations reported. Observation OBSERVED keeps only
+   * the groups they reported, and still confirms every unreviewed name in them, including a spelling in the same
+   * group none of them reported.
+   */
+  ConfirmAIProviders(request: ConfirmAIProvidersRequest, metadata?: Metadata): Promise<ConfirmAIProvidersResponse>;
+  ConfirmAIModels(request: ConfirmAIModelsRequest, metadata?: Metadata): Promise<ConfirmAIModelsResponse>;
+  ConfirmAIEfforts(request: ConfirmAIEffortsRequest, metadata?: Metadata): Promise<ConfirmAIEffortsResponse>;
+  ConfirmAIBillers(request: ConfirmAIBillersRequest, metadata?: Metadata): Promise<ConfirmAIBillersResponse>;
+}
+
+export const AdminGatewayServiceServiceName = "gateway.web.v1.AdminGatewayService";
+export class AdminGatewayServiceClientImpl implements AdminGatewayService {
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || AdminGatewayServiceServiceName;
+    this.rpc = rpc;
+    this.GetAdminStatus = this.GetAdminStatus.bind(this);
+    this.GenerateInviteCodes = this.GenerateInviteCodes.bind(this);
+    this.ListInviteCodes = this.ListInviteCodes.bind(this);
+    this.UpdateAIProvider = this.UpdateAIProvider.bind(this);
+    this.UpdateAIModel = this.UpdateAIModel.bind(this);
+    this.UpdateAIEffort = this.UpdateAIEffort.bind(this);
+    this.UpdateAIBiller = this.UpdateAIBiller.bind(this);
+    this.ConfirmAIProviders = this.ConfirmAIProviders.bind(this);
+    this.ConfirmAIModels = this.ConfirmAIModels.bind(this);
+    this.ConfirmAIEfforts = this.ConfirmAIEfforts.bind(this);
+    this.ConfirmAIBillers = this.ConfirmAIBillers.bind(this);
+  }
+  GetAdminStatus(request: GetAdminStatusRequest, metadata?: Metadata): Promise<GetAdminStatusResponse> {
+    const data = GetAdminStatusRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetAdminStatus", data, metadata);
+    return promise.then((data) => GetAdminStatusResponse.decode(new BinaryReader(data)));
+  }
+
+  GenerateInviteCodes(request: GenerateInviteCodesRequest, metadata?: Metadata): Promise<GenerateInviteCodesResponse> {
+    const data = GenerateInviteCodesRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GenerateInviteCodes", data, metadata);
+    return promise.then((data) => GenerateInviteCodesResponse.decode(new BinaryReader(data)));
+  }
+
+  ListInviteCodes(request: ListInviteCodesRequest, metadata?: Metadata): Promise<ListInviteCodesResponse> {
+    const data = ListInviteCodesRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ListInviteCodes", data, metadata);
+    return promise.then((data) => ListInviteCodesResponse.decode(new BinaryReader(data)));
+  }
+
+  UpdateAIProvider(request: UpdateAIProviderRequest, metadata?: Metadata): Promise<UpdateAIProviderResponse> {
+    const data = UpdateAIProviderRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "UpdateAIProvider", data, metadata);
+    return promise.then((data) => UpdateAIProviderResponse.decode(new BinaryReader(data)));
+  }
+
+  UpdateAIModel(request: UpdateAIModelRequest, metadata?: Metadata): Promise<UpdateAIModelResponse> {
+    const data = UpdateAIModelRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "UpdateAIModel", data, metadata);
+    return promise.then((data) => UpdateAIModelResponse.decode(new BinaryReader(data)));
+  }
+
+  UpdateAIEffort(request: UpdateAIEffortRequest, metadata?: Metadata): Promise<UpdateAIEffortResponse> {
+    const data = UpdateAIEffortRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "UpdateAIEffort", data, metadata);
+    return promise.then((data) => UpdateAIEffortResponse.decode(new BinaryReader(data)));
+  }
+
+  UpdateAIBiller(request: UpdateAIBillerRequest, metadata?: Metadata): Promise<UpdateAIBillerResponse> {
+    const data = UpdateAIBillerRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "UpdateAIBiller", data, metadata);
+    return promise.then((data) => UpdateAIBillerResponse.decode(new BinaryReader(data)));
+  }
+
+  ConfirmAIProviders(request: ConfirmAIProvidersRequest, metadata?: Metadata): Promise<ConfirmAIProvidersResponse> {
+    const data = ConfirmAIProvidersRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ConfirmAIProviders", data, metadata);
+    return promise.then((data) => ConfirmAIProvidersResponse.decode(new BinaryReader(data)));
+  }
+
+  ConfirmAIModels(request: ConfirmAIModelsRequest, metadata?: Metadata): Promise<ConfirmAIModelsResponse> {
+    const data = ConfirmAIModelsRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ConfirmAIModels", data, metadata);
+    return promise.then((data) => ConfirmAIModelsResponse.decode(new BinaryReader(data)));
+  }
+
+  ConfirmAIEfforts(request: ConfirmAIEffortsRequest, metadata?: Metadata): Promise<ConfirmAIEffortsResponse> {
+    const data = ConfirmAIEffortsRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ConfirmAIEfforts", data, metadata);
+    return promise.then((data) => ConfirmAIEffortsResponse.decode(new BinaryReader(data)));
+  }
+
+  ConfirmAIBillers(request: ConfirmAIBillersRequest, metadata?: Metadata): Promise<ConfirmAIBillersResponse> {
+    const data = ConfirmAIBillersRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ConfirmAIBillers", data, metadata);
+    return promise.then((data) => ConfirmAIBillersResponse.decode(new BinaryReader(data)));
+  }
+}
+
+interface Rpc {
+  request(service: string, method: string, data: Uint8Array, metadata?: Metadata): Promise<Uint8Array>;
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function toTimestamp(date: Date): Timestamp {
+  const seconds = Math.trunc(date.getTime() / 1_000);
+  const nanos = (date.getTime() % 1_000) * 1_000_000;
+  return { seconds, nanos };
+}
+
+function fromTimestamp(t: Timestamp): Date {
+  let millis = (t.seconds || 0) * 1_000;
+  millis += (t.nanos || 0) / 1_000_000;
+  return new globalThis.Date(millis);
+}
+
+function fromJsonTimestamp(o: any): Date {
+  if (o instanceof globalThis.Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new globalThis.Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
+  }
+}
+
+function longToNumber(int64: { toString(): string }): number {
+  const num = globalThis.Number(int64.toString());
+  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
   }
+  return num;
 }
 
 function isSet(value: any): boolean {