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

// Code generated by zapgen --target=ts; DO NOT EDIT.
// source: document-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 Document service (stable wire ids). */
export const DocumentMethod = {
  get: 1,
  getMany: 2,
  find: 3,
  create: 4,
  update: 5,
  delete: 6,
  duplicate: 7,
  downloadCertificate: 8,
  distribute: 9,
  redistribute: 10,
  search: 11,
  share: 12,
  download: 13,
  downloadBeta: 14,
  createDocumentTemporary: 15,
  getDocumentByToken: 16,
  findDocumentsInternal: 17,
  accessAuthRequest2FAEmail: 18,
  auditLogFind: 19,
  auditLogDownload: 20,
  inboxFind: 21,
  inboxGetCount: 22,
  attachmentCreate: 23,
  attachmentUpdate: 24,
  attachmentDelete: 25,
  attachmentFind: 26,
} as const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

/** Abstract RPC server for the Document service. Subclass and implement each method. */
export abstract class DocumentServer {
  abstract get(req: Uint8Array): Promise<Uint8Array>;
  abstract getMany(req: Uint8Array): Promise<Uint8Array>;
  abstract find(req: Uint8Array): Promise<Uint8Array>;
  abstract create(req: Uint8Array): Promise<Uint8Array>;
  abstract update(req: Uint8Array): Promise<Uint8Array>;
  abstract delete(req: Uint8Array): Promise<Uint8Array>;
  abstract duplicate(req: Uint8Array): Promise<Uint8Array>;
  abstract downloadCertificate(req: Uint8Array): Promise<Uint8Array>;
  abstract distribute(req: Uint8Array): Promise<Uint8Array>;
  abstract redistribute(req: Uint8Array): Promise<Uint8Array>;
  abstract search(req: Uint8Array): Promise<Uint8Array>;
  abstract share(req: Uint8Array): Promise<Uint8Array>;
  abstract download(req: Uint8Array): Promise<Uint8Array>;
  abstract downloadBeta(req: Uint8Array): Promise<Uint8Array>;
  abstract createDocumentTemporary(req: Uint8Array): Promise<Uint8Array>;
  abstract getDocumentByToken(req: Uint8Array): Promise<Uint8Array>;
  abstract findDocumentsInternal(req: Uint8Array): Promise<Uint8Array>;
  abstract accessAuthRequest2FAEmail(req: Uint8Array): Promise<Uint8Array>;
  abstract auditLogFind(req: Uint8Array): Promise<Uint8Array>;
  abstract auditLogDownload(req: Uint8Array): Promise<Uint8Array>;
  abstract inboxFind(req: Uint8Array): Promise<Uint8Array>;
  abstract inboxGetCount(req: Uint8Array): Promise<Uint8Array>;
  abstract attachmentCreate(req: Uint8Array): Promise<Uint8Array>;
  abstract attachmentUpdate(req: Uint8Array): Promise<Uint8Array>;
  abstract attachmentDelete(req: Uint8Array): Promise<Uint8Array>;
  abstract attachmentFind(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 DocumentMethod.get: {
        const body = await this.get(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.getMany: {
        const body = await this.getMany(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.find: {
        const body = await this.find(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.create: {
        const body = await this.create(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.update: {
        const body = await this.update(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.delete: {
        const body = await this.delete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.duplicate: {
        const body = await this.duplicate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.downloadCertificate: {
        const body = await this.downloadCertificate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.distribute: {
        const body = await this.distribute(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.redistribute: {
        const body = await this.redistribute(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.search: {
        const body = await this.search(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.share: {
        const body = await this.share(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.download: {
        const body = await this.download(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.downloadBeta: {
        const body = await this.downloadBeta(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.createDocumentTemporary: {
        const body = await this.createDocumentTemporary(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.getDocumentByToken: {
        const body = await this.getDocumentByToken(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.findDocumentsInternal: {
        const body = await this.findDocumentsInternal(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.accessAuthRequest2FAEmail: {
        const body = await this.accessAuthRequest2FAEmail(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.auditLogFind: {
        const body = await this.auditLogFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.auditLogDownload: {
        const body = await this.auditLogDownload(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.inboxFind: {
        const body = await this.inboxFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.inboxGetCount: {
        const body = await this.inboxGetCount(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.attachmentCreate: {
        const body = await this.attachmentCreate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.attachmentUpdate: {
        const body = await this.attachmentUpdate(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.attachmentDelete: {
        const body = await this.attachmentDelete(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      case DocumentMethod.attachmentFind: {
        const body = await this.attachmentFind(call.payload);
        return buildResponse(Status.OK, call.promiseID, body);
      }
      default:
        return buildResponse(Status.NotFound, call.promiseID, new Uint8Array(0));
    }
  }
}