esign/packages/trpc/zap/gen/admin-router_zap.ts

// Code generated by zapgen --target=ts; DO NOT EDIT.
// source: admin-router.zap

import {
  Builder,
  Message,
  StructView,
  buildRequest,
  parseRequest,
  buildResponse,
  NO_TARGET,
  Status,
  type Call,
  type Response,
} from "@zap-proto/zap";

const reqOff = {
  Body: 0,
} as const;
const reqSize = 8;

/** Zero-copy view into a ZAP-encoded Req message. */
export class Req extends StructView {
  /** Parse `b` and return a typed view. Throws on a wire-level check failure (magic, version, size). */
  static wrap(b: Uint8Array): Req {
    const root = Message.parse(b).root();
    return new Req(root.data, root.offset);
  }

  get body(): string { return this.text(reqOff.Body); }
}

/** Field values for newReq. */
export interface ReqInput {
  body: string;
}

/** Build a ZAP-encoded Req message from `in` and return the bytes. */
export function newReq(in_: ReqInput): Uint8Array {
  const b = new Builder(256);
  const ob = b.startObject(reqSize);
  ob.setText(reqOff.Body, in_.body);
  ob.finishAsRoot();
  return b.finish();
}


const respOff = {
  Body: 0,
} as const;
const respSize = 8;

/** Zero-copy view into a ZAP-encoded Resp message. */
export class Resp extends StructView {
  /** Parse `b` and return a typed view. Throws on a wire-level check failure (magic, version, size). */
  static wrap(b: Uint8Array): Resp {
    const root = Message.parse(b).root();
    return new Resp(root.data, root.offset);
  }

  get body(): string { return this.text(respOff.Body); }
}

/** Field values for newResp. */
export interface RespInput {
  body: string;
}

/** Build a ZAP-encoded Resp message from `in` and return the bytes. */
export function newResp(in_: RespInput): Uint8Array {
  const b = new Builder(256);
  const ob = b.startObject(respSize);
  ob.setText(respOff.Body, in_.body);
  ob.finishAsRoot();
  return b.finish();
}


/** Method ordinals for the Admin service (stable wire ids). */
export const AdminMethod = {
  organisationFind: 1,
  organisationGet: 2,
  organisationCreate: 3,
  organisationUpdate: 4,
  organisationSwapSubscription: 5,
  organisationMemberPromoteToOwner: 6,
  organisationMemberUpdateRole: 7,
  claimsFind: 8,
  claimsCreate: 9,
  claimsUpdate: 10,
  claimsDelete: 11,
  licenseResync: 12,
  userGet: 13,
  userUpdate: 14,
  userDelete: 15,
  userEnable: 16,
  userDisable: 17,
  userResetTwoFactor: 18,
  userFindTeams: 19,
  documentFind: 20,
  documentFindUnsealed: 21,
  documentDelete: 22,
  documentReseal: 23,
  documentFindJobs: 24,
  documentFindAuditLogs: 25,
  recipientUpdate: 26,
  emailDomainFind: 27,
  emailDomainGet: 28,
  emailDomainReregister: 29,
  updateSiteSetting: 30,
} as const;

/** Typed RPC client for the Admin service over a ZAP call channel. */
export interface AdminChannel {
  /** Ship one Call envelope and await its correlated Response. */
  call(envelope: Uint8Array): Promise<Response>;
}

export class AdminClient {
  constructor(private readonly channel: AdminChannel, private readonly cap: Uint8Array = new Uint8Array(0)) {}

  async organisationFind(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.organisationFind,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.organisationFind: status ${resp.status}`);
    }
    return resp.body;
  }

  async organisationGet(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.organisationGet,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.organisationGet: status ${resp.status}`);
    }
    return resp.body;
  }

  async organisationCreate(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.organisationCreate,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.organisationCreate: status ${resp.status}`);
    }
    return resp.body;
  }

  async organisationUpdate(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.organisationUpdate,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.organisationUpdate: status ${resp.status}`);
    }
    return resp.body;
  }

  async organisationSwapSubscription(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.organisationSwapSubscription,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.organisationSwapSubscription: status ${resp.status}`);
    }
    return resp.body;
  }

  async organisationMemberPromoteToOwner(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.organisationMemberPromoteToOwner,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.organisationMemberPromoteToOwner: status ${resp.status}`);
    }
    return resp.body;
  }

  async organisationMemberUpdateRole(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.organisationMemberUpdateRole,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.organisationMemberUpdateRole: status ${resp.status}`);
    }
    return resp.body;
  }

  async claimsFind(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.claimsFind,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.claimsFind: status ${resp.status}`);
    }
    return resp.body;
  }

  async claimsCreate(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.claimsCreate,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.claimsCreate: status ${resp.status}`);
    }
    return resp.body;
  }

  async claimsUpdate(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.claimsUpdate,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.claimsUpdate: status ${resp.status}`);
    }
    return resp.body;
  }

  async claimsDelete(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.claimsDelete,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.claimsDelete: status ${resp.status}`);
    }
    return resp.body;
  }

  async licenseResync(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.licenseResync,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.licenseResync: status ${resp.status}`);
    }
    return resp.body;
  }

  async userGet(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.userGet,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.userGet: status ${resp.status}`);
    }
    return resp.body;
  }

  async userUpdate(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.userUpdate,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.userUpdate: status ${resp.status}`);
    }
    return resp.body;
  }

  async userDelete(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.userDelete,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.userDelete: status ${resp.status}`);
    }
    return resp.body;
  }

  async userEnable(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.userEnable,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.userEnable: status ${resp.status}`);
    }
    return resp.body;
  }

  async userDisable(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.userDisable,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.userDisable: status ${resp.status}`);
    }
    return resp.body;
  }

  async userResetTwoFactor(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.userResetTwoFactor,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.userResetTwoFactor: status ${resp.status}`);
    }
    return resp.body;
  }

  async userFindTeams(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.userFindTeams,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.userFindTeams: status ${resp.status}`);
    }
    return resp.body;
  }

  async documentFind(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.documentFind,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.documentFind: status ${resp.status}`);
    }
    return resp.body;
  }

  async documentFindUnsealed(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.documentFindUnsealed,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.documentFindUnsealed: status ${resp.status}`);
    }
    return resp.body;
  }

  async documentDelete(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.documentDelete,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.documentDelete: status ${resp.status}`);
    }
    return resp.body;
  }

  async documentReseal(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.documentReseal,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.documentReseal: status ${resp.status}`);
    }
    return resp.body;
  }

  async documentFindJobs(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.documentFindJobs,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.documentFindJobs: status ${resp.status}`);
    }
    return resp.body;
  }

  async documentFindAuditLogs(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.documentFindAuditLogs,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.documentFindAuditLogs: status ${resp.status}`);
    }
    return resp.body;
  }

  async recipientUpdate(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.recipientUpdate,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.recipientUpdate: status ${resp.status}`);
    }
    return resp.body;
  }

  async emailDomainFind(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.emailDomainFind,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.emailDomainFind: status ${resp.status}`);
    }
    return resp.body;
  }

  async emailDomainGet(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.emailDomainGet,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.emailDomainGet: status ${resp.status}`);
    }
    return resp.body;
  }

  async emailDomainReregister(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.emailDomainReregister,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.emailDomainReregister: status ${resp.status}`);
    }
    return resp.body;
  }

  async updateSiteSetting(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: AdminMethod.updateSiteSetting,
      promiseID: 0,
      target: NO_TARGET,
      cap: this.cap,
      payload: req,
    });
    const resp = await this.channel.call(envelope);
    if (resp.status !== Status.OK) {
      throw new Error(`Admin.updateSiteSetting: status ${resp.status}`);
    }
    return resp.body;
  }

}

/** Abstract RPC server for the Admin service. Subclass and implement each method. */
export abstract class AdminServer {
  abstract organisationFind(req: Uint8Array): Promise<Uint8Array>;
  abstract organisationGet(req: Uint8Array): Promise<Uint8Array>;
  abstract organisationCreate(req: Uint8Array): Promise<Uint8Array>;
  abstract organisationUpdate(req: Uint8Array): Promise<Uint8Array>;
  abstract organisationSwapSubscription(req: Uint8Array): Promise<Uint8Array>;
  abstract organisationMemberPromoteToOwner(req: Uint8Array): Promise<Uint8Array>;
  abstract organisationMemberUpdateRole(req: Uint8Array): Promise<Uint8Array>;
  abstract claimsFind(req: Uint8Array): Promise<Uint8Array>;
  abstract claimsCreate(req: Uint8Array): Promise<Uint8Array>;
  abstract claimsUpdate(req: Uint8Array): Promise<Uint8Array>;
  abstract claimsDelete(req: Uint8Array): Promise<Uint8Array>;
  abstract licenseResync(req: Uint8Array): Promise<Uint8Array>;
  abstract userGet(req: Uint8Array): Promise<Uint8Array>;
  abstract userUpdate(req: Uint8Array): Promise<Uint8Array>;
  abstract userDelete(req: Uint8Array): Promise<Uint8Array>;
  abstract userEnable(req: Uint8Array): Promise<Uint8Array>;
  abstract userDisable(req: Uint8Array): Promise<Uint8Array>;
  abstract userResetTwoFactor(req: Uint8Array): Promise<Uint8Array>;
  abstract userFindTeams(req: Uint8Array): Promise<Uint8Array>;
  abstract documentFind(req: Uint8Array): Promise<Uint8Array>;
  abstract documentFindUnsealed(req: Uint8Array): Promise<Uint8Array>;
  abstract documentDelete(req: Uint8Array): Promise<Uint8Array>;
  abstract documentReseal(req: Uint8Array): Promise<Uint8Array>;
  abstract documentFindJobs(req: Uint8Array): Promise<Uint8Array>;
  abstract documentFindAuditLogs(req: Uint8Array): Promise<Uint8Array>;
  abstract recipientUpdate(req: Uint8Array): Promise<Uint8Array>;
  abstract emailDomainFind(req: Uint8Array): Promise<Uint8Array>;
  abstract emailDomainGet(req: Uint8Array): Promise<Uint8Array>;
  abstract emailDomainReregister(req: Uint8Array): Promise<Uint8Array>;
  abstract updateSiteSetting(req: Uint8Array): Promise<Uint8Array>;

  /** Decode a Call envelope, route by method ordinal, and build the Response envelope. */
  async dispatch(envelope: Uint8Array): Promise<Uint8Array> {
    const call: Call = parseRequest(envelope);
    switch (call.method) {
      case AdminMethod.organisationFind: {
        const body = await this.organisationFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.organisationGet: {
        const body = await this.organisationGet(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.organisationCreate: {
        const body = await this.organisationCreate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.organisationUpdate: {
        const body = await this.organisationUpdate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.organisationSwapSubscription: {
        const body = await this.organisationSwapSubscription(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.organisationMemberPromoteToOwner: {
        const body = await this.organisationMemberPromoteToOwner(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.organisationMemberUpdateRole: {
        const body = await this.organisationMemberUpdateRole(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.claimsFind: {
        const body = await this.claimsFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.claimsCreate: {
        const body = await this.claimsCreate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.claimsUpdate: {
        const body = await this.claimsUpdate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.claimsDelete: {
        const body = await this.claimsDelete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.licenseResync: {
        const body = await this.licenseResync(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.userGet: {
        const body = await this.userGet(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.userUpdate: {
        const body = await this.userUpdate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.userDelete: {
        const body = await this.userDelete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.userEnable: {
        const body = await this.userEnable(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.userDisable: {
        const body = await this.userDisable(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.userResetTwoFactor: {
        const body = await this.userResetTwoFactor(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.userFindTeams: {
        const body = await this.userFindTeams(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.documentFind: {
        const body = await this.documentFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.documentFindUnsealed: {
        const body = await this.documentFindUnsealed(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.documentDelete: {
        const body = await this.documentDelete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.documentReseal: {
        const body = await this.documentReseal(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.documentFindJobs: {
        const body = await this.documentFindJobs(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.documentFindAuditLogs: {
        const body = await this.documentFindAuditLogs(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.recipientUpdate: {
        const body = await this.recipientUpdate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.emailDomainFind: {
        const body = await this.emailDomainFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.emailDomainGet: {
        const body = await this.emailDomainGet(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.emailDomainReregister: {
        const body = await this.emailDomainReregister(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case AdminMethod.updateSiteSetting: {
        const body = await this.updateSiteSetting(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      default:
        return buildResponse(Status.NotFound, call.promiseID, new Uint8Array(0));
    }
  }
}