@miradorlabs/web-grpc 3.34.0 → 3.36.0

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

@@ -262,6 +262,56 @@ export interface AdminRelayHeartbeat_CountersEntry {
   value: number;
 }
 
+export interface ResolveOrgDetailsRequest {
+  /** UUIDs, at most 1000; a malformed id is a validation error. */
+  organizationIds: string[];
+}
+
+export interface ResolveOrgDetailsResponse {
+  status: ResponseStatus | undefined;
+  organizations: OrgDetails[];
+}
+
+export interface OrgDetails {
+  organizationId: string;
+  name: string;
+}
+
+export interface ResolveProjectDetailsRequest {
+  /** UUIDs, at most 1000; a malformed id is a validation error. */
+  projectIds: string[];
+}
+
+export interface ResolveProjectDetailsResponse {
+  status: ResponseStatus | undefined;
+  projects: ProjectDetails[];
+}
+
+/** A deleted project still resolves: its name is the one it had. */
+export interface ProjectDetails {
+  projectId: string;
+  organizationId: string;
+  name: string;
+}
+
+export interface ResolveUserDetailsRequest {
+  /** The Mirador account user UUID (terma.user.id). */
+  userId: string;
+}
+
+export interface ResolveUserDetailsResponse {
+  status: ResponseStatus | undefined;
+  user: UserDetails | undefined;
+}
+
+export interface UserDetails {
+  userId: string;
+  /** The primary email, or the first address when the user has no primary one. */
+  email: string;
+  /** The first and last name joined; empty when neither is set. */
+  name: string;
+}
+
 function createBaseGetAdminStatusRequest(): GetAdminStatusRequest {
   return {};
 }
@@ -3272,151 +3322,988 @@ export const AdminRelayHeartbeat_CountersEntry: MessageFns<AdminRelayHeartbeat_C
   },
 };
 
-/**
- * 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>;
-  /** SendInviteCodeEmail emails one available code to an address and records when and to whom it was sent. */
-  SendInviteCodeEmail(request: SendInviteCodeEmailRequest, metadata?: Metadata): Promise<SendInviteCodeEmailResponse>;
-  /**
-   * 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>;
-  /**
-   * Every Terma relay across the fleet with its latest heartbeat in full, one row per (organization, project, user,
-   * host), most recently seen first (keyset-paginated); it proxies
-   * telemetry.api.v1.TelemetryAdminService.ListRelayHeartbeats. Rows carry ids, not names.
-   */
-  ListRelayHeartbeats(
-    request: ListAdminRelayHeartbeatsRequest,
-    metadata?: Metadata,
-  ): Promise<ListAdminRelayHeartbeatsResponse>;
+function createBaseResolveOrgDetailsRequest(): ResolveOrgDetailsRequest {
+  return { organizationIds: [] };
 }
 
-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.SendInviteCodeEmail = this.SendInviteCodeEmail.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);
-    this.ListRelayHeartbeats = this.ListRelayHeartbeats.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 ResolveOrgDetailsRequest: MessageFns<ResolveOrgDetailsRequest> = {
+  encode(message: ResolveOrgDetailsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.organizationIds) {
+      writer.uint32(10).string(v!);
+    }
+    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): ResolveOrgDetailsRequest {
+    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 = createBaseResolveOrgDetailsRequest();
+      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;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
 
-  SendInviteCodeEmail(request: SendInviteCodeEmailRequest, metadata?: Metadata): Promise<SendInviteCodeEmailResponse> {
-    const data = SendInviteCodeEmailRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "SendInviteCodeEmail", data, metadata);
-    return promise.then((data) => SendInviteCodeEmailResponse.decode(new BinaryReader(data)));
-  }
+  fromJSON(object: any): ResolveOrgDetailsRequest {
+    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))
+        : [],
+    };
+  },
 
-  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)));
-  }
+  toJSON(message: ResolveOrgDetailsRequest): unknown {
+    const obj: any = {};
+    if (message.organizationIds?.length) {
+      obj.organizationIds = message.organizationIds;
+    }
+    return obj;
+  },
 
-  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)));
-  }
+  create<I extends Exact<DeepPartial<ResolveOrgDetailsRequest>, I>>(base?: I): ResolveOrgDetailsRequest {
+    return ResolveOrgDetailsRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ResolveOrgDetailsRequest>, I>>(object: I): ResolveOrgDetailsRequest {
+    const message = createBaseResolveOrgDetailsRequest();
+    message.organizationIds = object.organizationIds?.map((e) => e) || [];
+    return message;
+  },
+};
 
-  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)));
-  }
+function createBaseResolveOrgDetailsResponse(): ResolveOrgDetailsResponse {
+  return { status: undefined, organizations: [] };
+}
 
-  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)));
-  }
+export const ResolveOrgDetailsResponse: MessageFns<ResolveOrgDetailsResponse> = {
+  encode(message: ResolveOrgDetailsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.organizations) {
+      OrgDetails.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
 
-  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)));
-  }
+  decode(input: BinaryReader | Uint8Array, length?: number): ResolveOrgDetailsResponse {
+    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 = createBaseResolveOrgDetailsResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
 
-  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)));
-  }
+            message.status = ResponseStatus.decode(reader, reader.uint32());
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
 
-  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)));
-  }
+            message.organizations.push(OrgDetails.decode(reader, reader.uint32()));
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
 
-  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)));
-  }
+  fromJSON(object: any): ResolveOrgDetailsResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      organizations: globalThis.Array.isArray(object?.organizations)
+        ? object.organizations.map((e: any) => OrgDetails.fromJSON(e))
+        : [],
+    };
+  },
 
-  ListRelayHeartbeats(
-    request: ListAdminRelayHeartbeatsRequest,
-    metadata?: Metadata,
-  ): Promise<ListAdminRelayHeartbeatsResponse> {
+  toJSON(message: ResolveOrgDetailsResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.organizations?.length) {
+      obj.organizations = message.organizations.map((e) => OrgDetails.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ResolveOrgDetailsResponse>, I>>(base?: I): ResolveOrgDetailsResponse {
+    return ResolveOrgDetailsResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ResolveOrgDetailsResponse>, I>>(object: I): ResolveOrgDetailsResponse {
+    const message = createBaseResolveOrgDetailsResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.organizations = object.organizations?.map((e) => OrgDetails.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseOrgDetails(): OrgDetails {
+  return { organizationId: "", name: "" };
+}
+
+export const OrgDetails: MessageFns<OrgDetails> = {
+  encode(message: OrgDetails, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.organizationId !== "") {
+      writer.uint32(10).string(message.organizationId);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): OrgDetails {
+    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 = createBaseOrgDetails();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.organizationId = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.name = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): OrgDetails {
+    return {
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+    };
+  },
+
+  toJSON(message: OrgDetails): unknown {
+    const obj: any = {};
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<OrgDetails>, I>>(base?: I): OrgDetails {
+    return OrgDetails.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<OrgDetails>, I>>(object: I): OrgDetails {
+    const message = createBaseOrgDetails();
+    message.organizationId = object.organizationId ?? "";
+    message.name = object.name ?? "";
+    return message;
+  },
+};
+
+function createBaseResolveProjectDetailsRequest(): ResolveProjectDetailsRequest {
+  return { projectIds: [] };
+}
+
+export const ResolveProjectDetailsRequest: MessageFns<ResolveProjectDetailsRequest> = {
+  encode(message: ResolveProjectDetailsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.projectIds) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ResolveProjectDetailsRequest {
+    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 = createBaseResolveProjectDetailsRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.projectIds.push(reader.string());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ResolveProjectDetailsRequest {
+    return {
+      projectIds: globalThis.Array.isArray(object?.projectIds)
+        ? object.projectIds.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.project_ids)
+        ? object.project_ids.map((e: any) => globalThis.String(e))
+        : [],
+    };
+  },
+
+  toJSON(message: ResolveProjectDetailsRequest): unknown {
+    const obj: any = {};
+    if (message.projectIds?.length) {
+      obj.projectIds = message.projectIds;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ResolveProjectDetailsRequest>, I>>(base?: I): ResolveProjectDetailsRequest {
+    return ResolveProjectDetailsRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ResolveProjectDetailsRequest>, I>>(object: I): ResolveProjectDetailsRequest {
+    const message = createBaseResolveProjectDetailsRequest();
+    message.projectIds = object.projectIds?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseResolveProjectDetailsResponse(): ResolveProjectDetailsResponse {
+  return { status: undefined, projects: [] };
+}
+
+export const ResolveProjectDetailsResponse: MessageFns<ResolveProjectDetailsResponse> = {
+  encode(message: ResolveProjectDetailsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.projects) {
+      ProjectDetails.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ResolveProjectDetailsResponse {
+    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 = createBaseResolveProjectDetailsResponse();
+      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 !== 18) {
+              break;
+            }
+
+            message.projects.push(ProjectDetails.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): ResolveProjectDetailsResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      projects: globalThis.Array.isArray(object?.projects)
+        ? object.projects.map((e: any) => ProjectDetails.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: ResolveProjectDetailsResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.projects?.length) {
+      obj.projects = message.projects.map((e) => ProjectDetails.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ResolveProjectDetailsResponse>, I>>(base?: I): ResolveProjectDetailsResponse {
+    return ResolveProjectDetailsResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ResolveProjectDetailsResponse>, I>>(
+    object: I,
+  ): ResolveProjectDetailsResponse {
+    const message = createBaseResolveProjectDetailsResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.projects = object.projects?.map((e) => ProjectDetails.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseProjectDetails(): ProjectDetails {
+  return { projectId: "", organizationId: "", name: "" };
+}
+
+export const ProjectDetails: MessageFns<ProjectDetails> = {
+  encode(message: ProjectDetails, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.projectId !== "") {
+      writer.uint32(10).string(message.projectId);
+    }
+    if (message.organizationId !== "") {
+      writer.uint32(18).string(message.organizationId);
+    }
+    if (message.name !== "") {
+      writer.uint32(26).string(message.name);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ProjectDetails {
+    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 = createBaseProjectDetails();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.projectId = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.organizationId = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.name = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ProjectDetails {
+    return {
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+    };
+  },
+
+  toJSON(message: ProjectDetails): unknown {
+    const obj: any = {};
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ProjectDetails>, I>>(base?: I): ProjectDetails {
+    return ProjectDetails.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ProjectDetails>, I>>(object: I): ProjectDetails {
+    const message = createBaseProjectDetails();
+    message.projectId = object.projectId ?? "";
+    message.organizationId = object.organizationId ?? "";
+    message.name = object.name ?? "";
+    return message;
+  },
+};
+
+function createBaseResolveUserDetailsRequest(): ResolveUserDetailsRequest {
+  return { userId: "" };
+}
+
+export const ResolveUserDetailsRequest: MessageFns<ResolveUserDetailsRequest> = {
+  encode(message: ResolveUserDetailsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.userId !== "") {
+      writer.uint32(10).string(message.userId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ResolveUserDetailsRequest {
+    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 = createBaseResolveUserDetailsRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.userId = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ResolveUserDetailsRequest {
+    return {
+      userId: isSet(object.userId)
+        ? globalThis.String(object.userId)
+        : isSet(object.user_id)
+        ? globalThis.String(object.user_id)
+        : "",
+    };
+  },
+
+  toJSON(message: ResolveUserDetailsRequest): unknown {
+    const obj: any = {};
+    if (message.userId !== "") {
+      obj.userId = message.userId;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ResolveUserDetailsRequest>, I>>(base?: I): ResolveUserDetailsRequest {
+    return ResolveUserDetailsRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ResolveUserDetailsRequest>, I>>(object: I): ResolveUserDetailsRequest {
+    const message = createBaseResolveUserDetailsRequest();
+    message.userId = object.userId ?? "";
+    return message;
+  },
+};
+
+function createBaseResolveUserDetailsResponse(): ResolveUserDetailsResponse {
+  return { status: undefined, user: undefined };
+}
+
+export const ResolveUserDetailsResponse: MessageFns<ResolveUserDetailsResponse> = {
+  encode(message: ResolveUserDetailsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.user !== undefined) {
+      UserDetails.encode(message.user, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ResolveUserDetailsResponse {
+    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 = createBaseResolveUserDetailsResponse();
+      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 !== 18) {
+              break;
+            }
+
+            message.user = UserDetails.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): ResolveUserDetailsResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      user: isSet(object.user) ? UserDetails.fromJSON(object.user) : undefined,
+    };
+  },
+
+  toJSON(message: ResolveUserDetailsResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.user !== undefined) {
+      obj.user = UserDetails.toJSON(message.user);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ResolveUserDetailsResponse>, I>>(base?: I): ResolveUserDetailsResponse {
+    return ResolveUserDetailsResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ResolveUserDetailsResponse>, I>>(object: I): ResolveUserDetailsResponse {
+    const message = createBaseResolveUserDetailsResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.user = (object.user !== undefined && object.user !== null)
+      ? UserDetails.fromPartial(object.user)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseUserDetails(): UserDetails {
+  return { userId: "", email: "", name: "" };
+}
+
+export const UserDetails: MessageFns<UserDetails> = {
+  encode(message: UserDetails, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.userId !== "") {
+      writer.uint32(10).string(message.userId);
+    }
+    if (message.email !== "") {
+      writer.uint32(18).string(message.email);
+    }
+    if (message.name !== "") {
+      writer.uint32(26).string(message.name);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UserDetails {
+    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 = createBaseUserDetails();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.userId = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.email = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.name = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): UserDetails {
+    return {
+      userId: isSet(object.userId)
+        ? globalThis.String(object.userId)
+        : isSet(object.user_id)
+        ? globalThis.String(object.user_id)
+        : "",
+      email: isSet(object.email) ? globalThis.String(object.email) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+    };
+  },
+
+  toJSON(message: UserDetails): unknown {
+    const obj: any = {};
+    if (message.userId !== "") {
+      obj.userId = message.userId;
+    }
+    if (message.email !== "") {
+      obj.email = message.email;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UserDetails>, I>>(base?: I): UserDetails {
+    return UserDetails.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UserDetails>, I>>(object: I): UserDetails {
+    const message = createBaseUserDetails();
+    message.userId = object.userId ?? "";
+    message.email = object.email ?? "";
+    message.name = object.name ?? "";
+    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>;
+  /** SendInviteCodeEmail emails one available code to an address and records when and to whom it was sent. */
+  SendInviteCodeEmail(request: SendInviteCodeEmailRequest, metadata?: Metadata): Promise<SendInviteCodeEmailResponse>;
+  /**
+   * 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>;
+  /**
+   * Every Terma relay across the fleet with its latest heartbeat in full, one row per (organization, project, user,
+   * host), most recently seen first (keyset-paginated); it proxies
+   * telemetry.api.v1.TelemetryAdminService.ListRelayHeartbeats. Rows carry ids, not names.
+   */
+  ListRelayHeartbeats(
+    request: ListAdminRelayHeartbeatsRequest,
+    metadata?: Metadata,
+  ): Promise<ListAdminRelayHeartbeatsResponse>;
+  /**
+   * ResolveOrgDetails resolves organization ids to their names, in batch, across every organization of this gateway's
+   * product. Unknown ids, and ids of another product, are left out; it never errors on them. A malformed id, or more
+   * than 1000 ids, is a validation error. It proxies account.api.v1.AccountAdminService.ResolveOrgDetails.
+   */
+  ResolveOrgDetails(request: ResolveOrgDetailsRequest, metadata?: Metadata): Promise<ResolveOrgDetailsResponse>;
+  /**
+   * ResolveProjectDetails resolves project (team) ids to their names, in batch, across every organization of this
+   * gateway's product, deleted projects included. Unknown ids, and ids of another product, are left out; it never
+   * errors on them. A malformed id, or more than 1000 ids, is a validation error. It proxies
+   * account.api.v1.AccountAdminService.ResolveProjectDetails.
+   */
+  ResolveProjectDetails(
+    request: ResolveProjectDetailsRequest,
+    metadata?: Metadata,
+  ): Promise<ResolveProjectDetailsResponse>;
+  /**
+   * ResolveUserDetails resolves one user's email address and name, on demand. An unknown user, or one of another
+   * product, is NOT_FOUND; a malformed or empty id is a validation error; a user directory outage is UNAVAILABLE. It
+   * proxies account.api.v1.AccountAdminService.ResolveUserDetails.
+   */
+  ResolveUserDetails(request: ResolveUserDetailsRequest, metadata?: Metadata): Promise<ResolveUserDetailsResponse>;
+}
+
+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.SendInviteCodeEmail = this.SendInviteCodeEmail.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);
+    this.ListRelayHeartbeats = this.ListRelayHeartbeats.bind(this);
+    this.ResolveOrgDetails = this.ResolveOrgDetails.bind(this);
+    this.ResolveProjectDetails = this.ResolveProjectDetails.bind(this);
+    this.ResolveUserDetails = this.ResolveUserDetails.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)));
+  }
+
+  SendInviteCodeEmail(request: SendInviteCodeEmailRequest, metadata?: Metadata): Promise<SendInviteCodeEmailResponse> {
+    const data = SendInviteCodeEmailRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "SendInviteCodeEmail", data, metadata);
+    return promise.then((data) => SendInviteCodeEmailResponse.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)));
+  }
+
+  ListRelayHeartbeats(
+    request: ListAdminRelayHeartbeatsRequest,
+    metadata?: Metadata,
+  ): Promise<ListAdminRelayHeartbeatsResponse> {
     const data = ListAdminRelayHeartbeatsRequest.encode(request).finish();
     const promise = this.rpc.request(this.service, "ListRelayHeartbeats", data, metadata);
     return promise.then((data) => ListAdminRelayHeartbeatsResponse.decode(new BinaryReader(data)));
   }
+
+  ResolveOrgDetails(request: ResolveOrgDetailsRequest, metadata?: Metadata): Promise<ResolveOrgDetailsResponse> {
+    const data = ResolveOrgDetailsRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ResolveOrgDetails", data, metadata);
+    return promise.then((data) => ResolveOrgDetailsResponse.decode(new BinaryReader(data)));
+  }
+
+  ResolveProjectDetails(
+    request: ResolveProjectDetailsRequest,
+    metadata?: Metadata,
+  ): Promise<ResolveProjectDetailsResponse> {
+    const data = ResolveProjectDetailsRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ResolveProjectDetails", data, metadata);
+    return promise.then((data) => ResolveProjectDetailsResponse.decode(new BinaryReader(data)));
+  }
+
+  ResolveUserDetails(request: ResolveUserDetailsRequest, metadata?: Metadata): Promise<ResolveUserDetailsResponse> {
+    const data = ResolveUserDetailsRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ResolveUserDetails", data, metadata);
+    return promise.then((data) => ResolveUserDetailsResponse.decode(new BinaryReader(data)));
+  }
 }
 
 interface Rpc {