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

// Code generated by zapgen --target=ts; DO NOT EDIT.
// source: envelope-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 Envelope service (stable wire ids). */
export const EnvelopeMethod = {
  attachmentFind: 1,
  attachmentCreate: 2,
  attachmentUpdate: 3,
  attachmentDelete: 4,
  itemGetMany: 5,
  itemGetManyByToken: 6,
  itemCreateMany: 7,
  itemUpdateMany: 8,
  itemDelete: 9,
  itemDownload: 10,
  recipientGet: 11,
  recipientCreateMany: 12,
  recipientUpdateMany: 13,
  recipientDelete: 14,
  recipientSet: 15,
  fieldGet: 16,
  fieldCreateMany: 17,
  fieldUpdateMany: 18,
  fieldDelete: 19,
  fieldSet: 20,
  fieldSign: 21,
  find: 22,
  auditLogFind: 23,
  bulkMove: 24,
  bulkDelete: 25,
  editorGet: 26,
  get: 27,
  getMany: 28,
  create: 29,
  use: 30,
  update: 31,
  delete: 32,
  duplicate: 33,
  distribute: 34,
  redistribute: 35,
  signingStatus: 36,
} as const;

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

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

  async attachmentFind(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.attachmentFind,
      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(`Envelope.attachmentFind: status ${resp.status}`);
    }
    return resp.body;
  }

  async attachmentCreate(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.attachmentCreate,
      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(`Envelope.attachmentCreate: status ${resp.status}`);
    }
    return resp.body;
  }

  async attachmentUpdate(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.attachmentUpdate,
      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(`Envelope.attachmentUpdate: status ${resp.status}`);
    }
    return resp.body;
  }

  async attachmentDelete(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.attachmentDelete,
      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(`Envelope.attachmentDelete: status ${resp.status}`);
    }
    return resp.body;
  }

  async itemGetMany(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.itemGetMany,
      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(`Envelope.itemGetMany: status ${resp.status}`);
    }
    return resp.body;
  }

  async itemGetManyByToken(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.itemGetManyByToken,
      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(`Envelope.itemGetManyByToken: status ${resp.status}`);
    }
    return resp.body;
  }

  async itemCreateMany(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.itemCreateMany,
      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(`Envelope.itemCreateMany: status ${resp.status}`);
    }
    return resp.body;
  }

  async itemUpdateMany(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.itemUpdateMany,
      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(`Envelope.itemUpdateMany: status ${resp.status}`);
    }
    return resp.body;
  }

  async itemDelete(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.itemDelete,
      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(`Envelope.itemDelete: status ${resp.status}`);
    }
    return resp.body;
  }

  async itemDownload(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.itemDownload,
      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(`Envelope.itemDownload: status ${resp.status}`);
    }
    return resp.body;
  }

  async recipientGet(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.recipientGet,
      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(`Envelope.recipientGet: status ${resp.status}`);
    }
    return resp.body;
  }

  async recipientCreateMany(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.recipientCreateMany,
      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(`Envelope.recipientCreateMany: status ${resp.status}`);
    }
    return resp.body;
  }

  async recipientUpdateMany(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.recipientUpdateMany,
      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(`Envelope.recipientUpdateMany: status ${resp.status}`);
    }
    return resp.body;
  }

  async recipientDelete(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.recipientDelete,
      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(`Envelope.recipientDelete: status ${resp.status}`);
    }
    return resp.body;
  }

  async recipientSet(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.recipientSet,
      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(`Envelope.recipientSet: status ${resp.status}`);
    }
    return resp.body;
  }

  async fieldGet(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.fieldGet,
      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(`Envelope.fieldGet: status ${resp.status}`);
    }
    return resp.body;
  }

  async fieldCreateMany(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.fieldCreateMany,
      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(`Envelope.fieldCreateMany: status ${resp.status}`);
    }
    return resp.body;
  }

  async fieldUpdateMany(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.fieldUpdateMany,
      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(`Envelope.fieldUpdateMany: status ${resp.status}`);
    }
    return resp.body;
  }

  async fieldDelete(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.fieldDelete,
      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(`Envelope.fieldDelete: status ${resp.status}`);
    }
    return resp.body;
  }

  async fieldSet(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.fieldSet,
      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(`Envelope.fieldSet: status ${resp.status}`);
    }
    return resp.body;
  }

  async fieldSign(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.fieldSign,
      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(`Envelope.fieldSign: status ${resp.status}`);
    }
    return resp.body;
  }

  async find(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.find,
      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(`Envelope.find: status ${resp.status}`);
    }
    return resp.body;
  }

  async auditLogFind(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.auditLogFind,
      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(`Envelope.auditLogFind: status ${resp.status}`);
    }
    return resp.body;
  }

  async bulkMove(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.bulkMove,
      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(`Envelope.bulkMove: status ${resp.status}`);
    }
    return resp.body;
  }

  async bulkDelete(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.bulkDelete,
      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(`Envelope.bulkDelete: status ${resp.status}`);
    }
    return resp.body;
  }

  async editorGet(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.editorGet,
      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(`Envelope.editorGet: status ${resp.status}`);
    }
    return resp.body;
  }

  async get(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.get,
      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(`Envelope.get: status ${resp.status}`);
    }
    return resp.body;
  }

  async getMany(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.getMany,
      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(`Envelope.getMany: status ${resp.status}`);
    }
    return resp.body;
  }

  async create(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.create,
      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(`Envelope.create: status ${resp.status}`);
    }
    return resp.body;
  }

  async use(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.use,
      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(`Envelope.use: status ${resp.status}`);
    }
    return resp.body;
  }

  async update(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.update,
      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(`Envelope.update: status ${resp.status}`);
    }
    return resp.body;
  }

  async delete(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.delete,
      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(`Envelope.delete: status ${resp.status}`);
    }
    return resp.body;
  }

  async duplicate(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.duplicate,
      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(`Envelope.duplicate: status ${resp.status}`);
    }
    return resp.body;
  }

  async distribute(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.distribute,
      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(`Envelope.distribute: status ${resp.status}`);
    }
    return resp.body;
  }

  async redistribute(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.redistribute,
      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(`Envelope.redistribute: status ${resp.status}`);
    }
    return resp.body;
  }

  async signingStatus(req: Uint8Array): Promise<Uint8Array> {
    const envelope = buildRequest({
      method: EnvelopeMethod.signingStatus,
      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(`Envelope.signingStatus: status ${resp.status}`);
    }
    return resp.body;
  }

}

/** Abstract RPC server for the Envelope service. Subclass and implement each method. */
export abstract class EnvelopeServer {
  abstract attachmentFind(req: Uint8Array): Promise<Uint8Array>;
  abstract attachmentCreate(req: Uint8Array): Promise<Uint8Array>;
  abstract attachmentUpdate(req: Uint8Array): Promise<Uint8Array>;
  abstract attachmentDelete(req: Uint8Array): Promise<Uint8Array>;
  abstract itemGetMany(req: Uint8Array): Promise<Uint8Array>;
  abstract itemGetManyByToken(req: Uint8Array): Promise<Uint8Array>;
  abstract itemCreateMany(req: Uint8Array): Promise<Uint8Array>;
  abstract itemUpdateMany(req: Uint8Array): Promise<Uint8Array>;
  abstract itemDelete(req: Uint8Array): Promise<Uint8Array>;
  abstract itemDownload(req: Uint8Array): Promise<Uint8Array>;
  abstract recipientGet(req: Uint8Array): Promise<Uint8Array>;
  abstract recipientCreateMany(req: Uint8Array): Promise<Uint8Array>;
  abstract recipientUpdateMany(req: Uint8Array): Promise<Uint8Array>;
  abstract recipientDelete(req: Uint8Array): Promise<Uint8Array>;
  abstract recipientSet(req: Uint8Array): Promise<Uint8Array>;
  abstract fieldGet(req: Uint8Array): Promise<Uint8Array>;
  abstract fieldCreateMany(req: Uint8Array): Promise<Uint8Array>;
  abstract fieldUpdateMany(req: Uint8Array): Promise<Uint8Array>;
  abstract fieldDelete(req: Uint8Array): Promise<Uint8Array>;
  abstract fieldSet(req: Uint8Array): Promise<Uint8Array>;
  abstract fieldSign(req: Uint8Array): Promise<Uint8Array>;
  abstract find(req: Uint8Array): Promise<Uint8Array>;
  abstract auditLogFind(req: Uint8Array): Promise<Uint8Array>;
  abstract bulkMove(req: Uint8Array): Promise<Uint8Array>;
  abstract bulkDelete(req: Uint8Array): Promise<Uint8Array>;
  abstract editorGet(req: Uint8Array): Promise<Uint8Array>;
  abstract get(req: Uint8Array): Promise<Uint8Array>;
  abstract getMany(req: Uint8Array): Promise<Uint8Array>;
  abstract create(req: Uint8Array): Promise<Uint8Array>;
  abstract use(req: Uint8Array): Promise<Uint8Array>;
  abstract update(req: Uint8Array): Promise<Uint8Array>;
  abstract delete(req: Uint8Array): Promise<Uint8Array>;
  abstract duplicate(req: Uint8Array): Promise<Uint8Array>;
  abstract distribute(req: Uint8Array): Promise<Uint8Array>;
  abstract redistribute(req: Uint8Array): Promise<Uint8Array>;
  abstract signingStatus(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 EnvelopeMethod.attachmentFind: {
        const body = await this.attachmentFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.attachmentCreate: {
        const body = await this.attachmentCreate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.attachmentUpdate: {
        const body = await this.attachmentUpdate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.attachmentDelete: {
        const body = await this.attachmentDelete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.itemGetMany: {
        const body = await this.itemGetMany(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.itemGetManyByToken: {
        const body = await this.itemGetManyByToken(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.itemCreateMany: {
        const body = await this.itemCreateMany(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.itemUpdateMany: {
        const body = await this.itemUpdateMany(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.itemDelete: {
        const body = await this.itemDelete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.itemDownload: {
        const body = await this.itemDownload(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.recipientGet: {
        const body = await this.recipientGet(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.recipientCreateMany: {
        const body = await this.recipientCreateMany(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.recipientUpdateMany: {
        const body = await this.recipientUpdateMany(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.recipientDelete: {
        const body = await this.recipientDelete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.recipientSet: {
        const body = await this.recipientSet(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.fieldGet: {
        const body = await this.fieldGet(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.fieldCreateMany: {
        const body = await this.fieldCreateMany(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.fieldUpdateMany: {
        const body = await this.fieldUpdateMany(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.fieldDelete: {
        const body = await this.fieldDelete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.fieldSet: {
        const body = await this.fieldSet(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.fieldSign: {
        const body = await this.fieldSign(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.find: {
        const body = await this.find(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.auditLogFind: {
        const body = await this.auditLogFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.bulkMove: {
        const body = await this.bulkMove(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.bulkDelete: {
        const body = await this.bulkDelete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.editorGet: {
        const body = await this.editorGet(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.get: {
        const body = await this.get(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.getMany: {
        const body = await this.getMany(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.create: {
        const body = await this.create(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.use: {
        const body = await this.use(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.update: {
        const body = await this.update(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.delete: {
        const body = await this.delete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.duplicate: {
        const body = await this.duplicate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.distribute: {
        const body = await this.distribute(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.redistribute: {
        const body = await this.redistribute(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case EnvelopeMethod.signingStatus: {
        const body = await this.signingStatus(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      default:
        return buildResponse(Status.NotFound, call.promiseID, new Uint8Array(0));
    }
  }
}