@0xsequence/builder 0.0.0-20241216114019

package/dist/0xsequence-builder.esm.js

@@ -0,0 +1,454 @@
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+/* eslint-disable */
+// NOTE: this is just a subset of the builder api to scope down the
+// surface area of the client.
+//
+// In the future we can include additional interfaces as needed.
+const WebrpcHeader = 'Webrpc';
+const WebrpcHeaderValue = 'webrpc@v0.22.0;gen-typescript@v0.16.1;sequence-builder@v0.1.0';
+
+// WebRPC description and code-gen version
+const WebRPCVersion = 'v1';
+
+// Schema version of your RIDL schema
+const WebRPCSchemaVersion = 'v0.1.0';
+
+// Schema hash generated from your RIDL schema
+const WebRPCSchemaHash = '5b580e1afeb26e0b4a8ee026271e2466760da0aa';
+function VersionFromHeader(headers) {
+  const headerValue = headers.get(WebrpcHeader);
+  if (!headerValue) {
+    return {
+      webrpcGenVersion: '',
+      codeGenName: '',
+      codeGenVersion: '',
+      schemaName: '',
+      schemaVersion: ''
+    };
+  }
+  return parseWebrpcGenVersions(headerValue);
+}
+function parseWebrpcGenVersions(header) {
+  const versions = header.split(';');
+  if (versions.length < 3) {
+    return {
+      webrpcGenVersion: '',
+      codeGenName: '',
+      codeGenVersion: '',
+      schemaName: '',
+      schemaVersion: ''
+    };
+  }
+  const [_, webrpcGenVersion] = versions[0].split('@');
+  const [codeGenName, codeGenVersion] = versions[1].split('@');
+  const [schemaName, schemaVersion] = versions[2].split('@');
+  return {
+    webrpcGenVersion,
+    codeGenName,
+    codeGenVersion,
+    schemaName,
+    schemaVersion
+  };
+}
+
+//
+// Types
+//
+
+//
+// Client
+//
+class Builder {
+  constructor(hostname, fetch) {
+    this.hostname = void 0;
+    this.fetch = void 0;
+    this.path = '/rpc/Builder/';
+    this.ping = (headers, signal) => {
+      return this.fetch(this.url('Ping'), createHTTPRequest({}, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: _data.status
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.registerAudienceContact = (args, headers, signal) => {
+      return this.fetch(this.url('RegisterAudienceContact'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            ok: _data.ok
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.getRegisteredAudienceContact = (args, headers, signal) => {
+      return this.fetch(this.url('GetRegisteredAudienceContact'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            contact: _data.contact
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.getAudienceRegistrationPublicStatus = (args, headers, signal) => {
+      return this.fetch(this.url('GetAudienceRegistrationPublicStatus'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: _data.status
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.isAudienceContactRegistered = (args, headers, signal) => {
+      return this.fetch(this.url('IsAudienceContactRegistered'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            registered: _data.registered
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.hostname = hostname.replace(/\/*$/, '');
+    this.fetch = (input, init) => fetch(input, init);
+  }
+  url(name) {
+    return this.hostname + this.path + name;
+  }
+}
+const createHTTPRequest = (body = {}, headers = {}, signal = null) => {
+  const reqHeaders = _extends({}, headers, {
+    'Content-Type': 'application/json'
+  });
+  reqHeaders[WebrpcHeader] = WebrpcHeaderValue;
+  return {
+    method: 'POST',
+    headers: reqHeaders,
+    body: JSON.stringify(body || {}),
+    signal
+  };
+};
+const buildResponse = res => {
+  return res.text().then(text => {
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch (error) {
+      let message = '';
+      if (error instanceof Error) {
+        message = error.message;
+      }
+      throw WebrpcBadResponseError.new({
+        status: res.status,
+        cause: `JSON.parse(): ${message}: response text: ${text}`
+      });
+    }
+    if (!res.ok) {
+      const code = typeof data.code === 'number' ? data.code : 0;
+      throw (webrpcErrorByCode[code] || WebrpcError).new(data);
+    }
+    return data;
+  });
+};
+
+//
+// Errors
+//
+
+class WebrpcError extends Error {
+  constructor(name, code, message, status, cause) {
+    super(message);
+    this.name = void 0;
+    this.code = void 0;
+    this.message = void 0;
+    this.status = void 0;
+    this.cause = void 0;
+    /** @deprecated Use message instead of msg. Deprecated in webrpc v0.11.0. */
+    this.msg = void 0;
+    this.name = name || 'WebrpcError';
+    this.code = typeof code === 'number' ? code : 0;
+    this.message = message || `endpoint error ${this.code}`;
+    this.msg = this.message;
+    this.status = typeof status === 'number' ? status : 0;
+    this.cause = cause;
+    Object.setPrototypeOf(this, WebrpcError.prototype);
+  }
+  static new(payload) {
+    return new this(payload.error, payload.code, payload.message || payload.msg, payload.status, payload.cause);
+  }
+}
+
+// Webrpc errors
+
+class WebrpcEndpointError extends WebrpcError {
+  constructor(name = 'WebrpcEndpoint', code = 0, message = 'endpoint error', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcEndpointError.prototype);
+  }
+}
+class WebrpcRequestFailedError extends WebrpcError {
+  constructor(name = 'WebrpcRequestFailed', code = -1, message = 'request failed', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcRequestFailedError.prototype);
+  }
+}
+class WebrpcBadRouteError extends WebrpcError {
+  constructor(name = 'WebrpcBadRoute', code = -2, message = 'bad route', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadRouteError.prototype);
+  }
+}
+class WebrpcBadMethodError extends WebrpcError {
+  constructor(name = 'WebrpcBadMethod', code = -3, message = 'bad method', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadMethodError.prototype);
+  }
+}
+class WebrpcBadRequestError extends WebrpcError {
+  constructor(name = 'WebrpcBadRequest', code = -4, message = 'bad request', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadRequestError.prototype);
+  }
+}
+class WebrpcBadResponseError extends WebrpcError {
+  constructor(name = 'WebrpcBadResponse', code = -5, message = 'bad response', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadResponseError.prototype);
+  }
+}
+class WebrpcServerPanicError extends WebrpcError {
+  constructor(name = 'WebrpcServerPanic', code = -6, message = 'server panic', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcServerPanicError.prototype);
+  }
+}
+class WebrpcInternalErrorError extends WebrpcError {
+  constructor(name = 'WebrpcInternalError', code = -7, message = 'internal error', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcInternalErrorError.prototype);
+  }
+}
+class WebrpcClientDisconnectedError extends WebrpcError {
+  constructor(name = 'WebrpcClientDisconnected', code = -8, message = 'client disconnected', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcClientDisconnectedError.prototype);
+  }
+}
+class WebrpcStreamLostError extends WebrpcError {
+  constructor(name = 'WebrpcStreamLost', code = -9, message = 'stream lost', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcStreamLostError.prototype);
+  }
+}
+class WebrpcStreamFinishedError extends WebrpcError {
+  constructor(name = 'WebrpcStreamFinished', code = -10, message = 'stream finished', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcStreamFinishedError.prototype);
+  }
+}
+
+// Schema errors
+
+class UnauthorizedError extends WebrpcError {
+  constructor(name = 'Unauthorized', code = 1000, message = 'Unauthorized access', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, UnauthorizedError.prototype);
+  }
+}
+class PermissionDeniedError extends WebrpcError {
+  constructor(name = 'PermissionDenied', code = 1001, message = 'Permission denied', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, PermissionDeniedError.prototype);
+  }
+}
+class SessionExpiredError extends WebrpcError {
+  constructor(name = 'SessionExpired', code = 1002, message = 'Session expired', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, SessionExpiredError.prototype);
+  }
+}
+class MethodNotFoundError extends WebrpcError {
+  constructor(name = 'MethodNotFound', code = 1003, message = 'Method not found', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, MethodNotFoundError.prototype);
+  }
+}
+class RequestConflictError extends WebrpcError {
+  constructor(name = 'RequestConflict', code = 1004, message = 'Conflict with target resource', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, RequestConflictError.prototype);
+  }
+}
+class ServiceDisabledError extends WebrpcError {
+  constructor(name = 'ServiceDisabled', code = 1005, message = 'Service disabled', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, ServiceDisabledError.prototype);
+  }
+}
+class TimeoutError extends WebrpcError {
+  constructor(name = 'Timeout', code = 2000, message = 'Request timed out', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, TimeoutError.prototype);
+  }
+}
+class InvalidArgumentError extends WebrpcError {
+  constructor(name = 'InvalidArgument', code = 2001, message = 'Invalid argument', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, InvalidArgumentError.prototype);
+  }
+}
+class NotFoundError extends WebrpcError {
+  constructor(name = 'NotFound', code = 3000, message = 'Resource not found', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, NotFoundError.prototype);
+  }
+}
+class UserNotFoundError extends WebrpcError {
+  constructor(name = 'UserNotFound', code = 3001, message = 'User not found', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, UserNotFoundError.prototype);
+  }
+}
+class ProjectNotFoundError extends WebrpcError {
+  constructor(name = 'ProjectNotFound', code = 3002, message = 'Project not found', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, ProjectNotFoundError.prototype);
+  }
+}
+class AlreadyCollaboratorError extends WebrpcError {
+  constructor(name = 'AlreadyCollaborator', code = 4001, message = 'Already a collaborator', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, AlreadyCollaboratorError.prototype);
+  }
+}
+let errors = /*#__PURE__*/function (errors) {
+  errors["WebrpcEndpoint"] = "WebrpcEndpoint";
+  errors["WebrpcRequestFailed"] = "WebrpcRequestFailed";
+  errors["WebrpcBadRoute"] = "WebrpcBadRoute";
+  errors["WebrpcBadMethod"] = "WebrpcBadMethod";
+  errors["WebrpcBadRequest"] = "WebrpcBadRequest";
+  errors["WebrpcBadResponse"] = "WebrpcBadResponse";
+  errors["WebrpcServerPanic"] = "WebrpcServerPanic";
+  errors["WebrpcInternalError"] = "WebrpcInternalError";
+  errors["WebrpcClientDisconnected"] = "WebrpcClientDisconnected";
+  errors["WebrpcStreamLost"] = "WebrpcStreamLost";
+  errors["WebrpcStreamFinished"] = "WebrpcStreamFinished";
+  errors["Unauthorized"] = "Unauthorized";
+  errors["PermissionDenied"] = "PermissionDenied";
+  errors["SessionExpired"] = "SessionExpired";
+  errors["MethodNotFound"] = "MethodNotFound";
+  errors["RequestConflict"] = "RequestConflict";
+  errors["ServiceDisabled"] = "ServiceDisabled";
+  errors["Timeout"] = "Timeout";
+  errors["InvalidArgument"] = "InvalidArgument";
+  errors["NotFound"] = "NotFound";
+  errors["UserNotFound"] = "UserNotFound";
+  errors["ProjectNotFound"] = "ProjectNotFound";
+  return errors;
+}({});
+let WebrpcErrorCodes = /*#__PURE__*/function (WebrpcErrorCodes) {
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcEndpoint"] = 0] = "WebrpcEndpoint";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcRequestFailed"] = -1] = "WebrpcRequestFailed";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcBadRoute"] = -2] = "WebrpcBadRoute";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcBadMethod"] = -3] = "WebrpcBadMethod";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcBadRequest"] = -4] = "WebrpcBadRequest";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcBadResponse"] = -5] = "WebrpcBadResponse";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcServerPanic"] = -6] = "WebrpcServerPanic";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcInternalError"] = -7] = "WebrpcInternalError";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcClientDisconnected"] = -8] = "WebrpcClientDisconnected";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcStreamLost"] = -9] = "WebrpcStreamLost";
+  WebrpcErrorCodes[WebrpcErrorCodes["WebrpcStreamFinished"] = -10] = "WebrpcStreamFinished";
+  WebrpcErrorCodes[WebrpcErrorCodes["Unauthorized"] = 1000] = "Unauthorized";
+  WebrpcErrorCodes[WebrpcErrorCodes["PermissionDenied"] = 1001] = "PermissionDenied";
+  WebrpcErrorCodes[WebrpcErrorCodes["SessionExpired"] = 1002] = "SessionExpired";
+  WebrpcErrorCodes[WebrpcErrorCodes["MethodNotFound"] = 1003] = "MethodNotFound";
+  WebrpcErrorCodes[WebrpcErrorCodes["RequestConflict"] = 1004] = "RequestConflict";
+  WebrpcErrorCodes[WebrpcErrorCodes["ServiceDisabled"] = 1005] = "ServiceDisabled";
+  WebrpcErrorCodes[WebrpcErrorCodes["Timeout"] = 2000] = "Timeout";
+  WebrpcErrorCodes[WebrpcErrorCodes["InvalidArgument"] = 2001] = "InvalidArgument";
+  WebrpcErrorCodes[WebrpcErrorCodes["NotFound"] = 3000] = "NotFound";
+  WebrpcErrorCodes[WebrpcErrorCodes["UserNotFound"] = 3001] = "UserNotFound";
+  WebrpcErrorCodes[WebrpcErrorCodes["ProjectNotFound"] = 3002] = "ProjectNotFound";
+  return WebrpcErrorCodes;
+}({});
+const webrpcErrorByCode = {
+  [0]: WebrpcEndpointError,
+  [-1]: WebrpcRequestFailedError,
+  [-2]: WebrpcBadRouteError,
+  [-3]: WebrpcBadMethodError,
+  [-4]: WebrpcBadRequestError,
+  [-5]: WebrpcBadResponseError,
+  [-6]: WebrpcServerPanicError,
+  [-7]: WebrpcInternalErrorError,
+  [-8]: WebrpcClientDisconnectedError,
+  [-9]: WebrpcStreamLostError,
+  [-10]: WebrpcStreamFinishedError,
+  [1000]: UnauthorizedError,
+  [1001]: PermissionDeniedError,
+  [1002]: SessionExpiredError,
+  [1003]: MethodNotFoundError,
+  [1004]: RequestConflictError,
+  [1005]: ServiceDisabledError,
+  [2000]: TimeoutError,
+  [2001]: InvalidArgumentError,
+  [3000]: NotFoundError,
+  [3001]: UserNotFoundError,
+  [3002]: ProjectNotFoundError
+};
+
+class SequenceBuilderClient extends Builder {
+  constructor(projectAccessKey, apiUrl) {
+    const hostname = apiUrl != null ? apiUrl : 'https://api.sequence.build';
+    super(hostname.endsWith('/') ? hostname.slice(0, -1) : hostname, fetch);
+    this.projectAccessKey = projectAccessKey;
+    this._fetch = (input, init) => {
+      // automatically include access key auth header to requests
+      // if its been set on the api client
+      const headers = {};
+      const projectAccessKey = this.projectAccessKey;
+      if (projectAccessKey && projectAccessKey.length > 0) {
+        headers['X-Access-Key'] = projectAccessKey;
+      }
+
+      // before the request is made
+      init.headers = _extends({}, init.headers, headers);
+      return fetch(input, init);
+    };
+    this.fetch = this._fetch;
+  }
+}
+
+export { AlreadyCollaboratorError, Builder, InvalidArgumentError, MethodNotFoundError, NotFoundError, PermissionDeniedError, ProjectNotFoundError, RequestConflictError, SequenceBuilderClient, ServiceDisabledError, SessionExpiredError, TimeoutError, UnauthorizedError, UserNotFoundError, VersionFromHeader, WebRPCSchemaHash, WebRPCSchemaVersion, WebRPCVersion, WebrpcBadMethodError, WebrpcBadRequestError, WebrpcBadResponseError, WebrpcBadRouteError, WebrpcClientDisconnectedError, WebrpcEndpointError, WebrpcError, WebrpcErrorCodes, WebrpcHeader, WebrpcHeaderValue, WebrpcInternalErrorError, WebrpcRequestFailedError, WebrpcServerPanicError, WebrpcStreamFinishedError, WebrpcStreamLostError, errors, webrpcErrorByCode };

package/dist/declarations/src/builder.gen.d.ts

@@ -0,0 +1,222 @@
+export declare const WebrpcHeader = "Webrpc";
+export declare const WebrpcHeaderValue = "webrpc@v0.22.0;gen-typescript@v0.16.1;sequence-builder@v0.1.0";
+export declare const WebRPCVersion = "v1";
+export declare const WebRPCSchemaVersion = "v0.1.0";
+export declare const WebRPCSchemaHash = "5b580e1afeb26e0b4a8ee026271e2466760da0aa";
+type WebrpcGenVersions = {
+    webrpcGenVersion: string;
+    codeGenName: string;
+    codeGenVersion: string;
+    schemaName: string;
+    schemaVersion: string;
+};
+export declare function VersionFromHeader(headers: Headers): WebrpcGenVersions;
+export interface AudienceContact {
+    id?: number;
+    audienceId: number;
+    name?: string;
+    address: string;
+    email?: string;
+    userIp?: string;
+    stage?: number;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface AudienceRegistrationStatus {
+    totalCount: number;
+}
+export interface WalletProof {
+    address: string;
+    message: string;
+    signature: string;
+    chainId: number;
+}
+export interface Builder {
+    ping(headers?: object, signal?: AbortSignal): Promise<PingReturn>;
+    registerAudienceContact(args: RegisterAudienceContactArgs, headers?: object, signal?: AbortSignal): Promise<RegisterAudienceContactReturn>;
+    getRegisteredAudienceContact(args: GetRegisteredAudienceContactArgs, headers?: object, signal?: AbortSignal): Promise<GetRegisteredAudienceContactReturn>;
+    getAudienceRegistrationPublicStatus(args: GetAudienceRegistrationPublicStatusArgs, headers?: object, signal?: AbortSignal): Promise<GetAudienceRegistrationPublicStatusReturn>;
+    isAudienceContactRegistered(args: IsAudienceContactRegisteredArgs, headers?: object, signal?: AbortSignal): Promise<IsAudienceContactRegisteredReturn>;
+}
+export interface PingArgs {
+}
+export interface PingReturn {
+    status: boolean;
+}
+export interface RegisterAudienceContactArgs {
+    projectId: number;
+    audienceId: number;
+    contact: AudienceContact;
+    walletProof: WalletProof;
+}
+export interface RegisterAudienceContactReturn {
+    ok: boolean;
+}
+export interface GetRegisteredAudienceContactArgs {
+    projectId: number;
+    audienceId: number;
+    walletProof: WalletProof;
+}
+export interface GetRegisteredAudienceContactReturn {
+    contact: AudienceContact;
+}
+export interface GetAudienceRegistrationPublicStatusArgs {
+    projectId: number;
+    audienceId: number;
+}
+export interface GetAudienceRegistrationPublicStatusReturn {
+    status: AudienceRegistrationStatus;
+}
+export interface IsAudienceContactRegisteredArgs {
+    projectId: number;
+    audienceId: number;
+    walletAddress: string;
+}
+export interface IsAudienceContactRegisteredReturn {
+    registered: boolean;
+}
+export declare class Builder implements Builder {
+    protected hostname: string;
+    protected fetch: Fetch;
+    protected path: string;
+    constructor(hostname: string, fetch: Fetch);
+    private url;
+    ping: (headers?: object, signal?: AbortSignal) => Promise<PingReturn>;
+    registerAudienceContact: (args: RegisterAudienceContactArgs, headers?: object, signal?: AbortSignal) => Promise<RegisterAudienceContactReturn>;
+    getRegisteredAudienceContact: (args: GetRegisteredAudienceContactArgs, headers?: object, signal?: AbortSignal) => Promise<GetRegisteredAudienceContactReturn>;
+    getAudienceRegistrationPublicStatus: (args: GetAudienceRegistrationPublicStatusArgs, headers?: object, signal?: AbortSignal) => Promise<GetAudienceRegistrationPublicStatusReturn>;
+    isAudienceContactRegistered: (args: IsAudienceContactRegisteredArgs, headers?: object, signal?: AbortSignal) => Promise<IsAudienceContactRegisteredReturn>;
+}
+export declare class WebrpcError extends Error {
+    name: string;
+    code: number;
+    message: string;
+    status: number;
+    cause?: string;
+    /** @deprecated Use message instead of msg. Deprecated in webrpc v0.11.0. */
+    msg: string;
+    constructor(name: string, code: number, message: string, status: number, cause?: string);
+    static new(payload: any): WebrpcError;
+}
+export declare class WebrpcEndpointError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcRequestFailedError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcBadRouteError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcBadMethodError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcBadRequestError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcBadResponseError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcServerPanicError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcInternalErrorError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcClientDisconnectedError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcStreamLostError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class WebrpcStreamFinishedError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class UnauthorizedError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class PermissionDeniedError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class SessionExpiredError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class MethodNotFoundError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class RequestConflictError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class ServiceDisabledError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class TimeoutError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class InvalidArgumentError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class NotFoundError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class UserNotFoundError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class ProjectNotFoundError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare class AlreadyCollaboratorError extends WebrpcError {
+    constructor(name?: string, code?: number, message?: string, status?: number, cause?: string);
+}
+export declare enum errors {
+    WebrpcEndpoint = "WebrpcEndpoint",
+    WebrpcRequestFailed = "WebrpcRequestFailed",
+    WebrpcBadRoute = "WebrpcBadRoute",
+    WebrpcBadMethod = "WebrpcBadMethod",
+    WebrpcBadRequest = "WebrpcBadRequest",
+    WebrpcBadResponse = "WebrpcBadResponse",
+    WebrpcServerPanic = "WebrpcServerPanic",
+    WebrpcInternalError = "WebrpcInternalError",
+    WebrpcClientDisconnected = "WebrpcClientDisconnected",
+    WebrpcStreamLost = "WebrpcStreamLost",
+    WebrpcStreamFinished = "WebrpcStreamFinished",
+    Unauthorized = "Unauthorized",
+    PermissionDenied = "PermissionDenied",
+    SessionExpired = "SessionExpired",
+    MethodNotFound = "MethodNotFound",
+    RequestConflict = "RequestConflict",
+    ServiceDisabled = "ServiceDisabled",
+    Timeout = "Timeout",
+    InvalidArgument = "InvalidArgument",
+    NotFound = "NotFound",
+    UserNotFound = "UserNotFound",
+    ProjectNotFound = "ProjectNotFound"
+}
+export declare enum WebrpcErrorCodes {
+    WebrpcEndpoint = 0,
+    WebrpcRequestFailed = -1,
+    WebrpcBadRoute = -2,
+    WebrpcBadMethod = -3,
+    WebrpcBadRequest = -4,
+    WebrpcBadResponse = -5,
+    WebrpcServerPanic = -6,
+    WebrpcInternalError = -7,
+    WebrpcClientDisconnected = -8,
+    WebrpcStreamLost = -9,
+    WebrpcStreamFinished = -10,
+    Unauthorized = 1000,
+    PermissionDenied = 1001,
+    SessionExpired = 1002,
+    MethodNotFound = 1003,
+    RequestConflict = 1004,
+    ServiceDisabled = 1005,
+    Timeout = 2000,
+    InvalidArgument = 2001,
+    NotFound = 3000,
+    UserNotFound = 3001,
+    ProjectNotFound = 3002
+}
+export declare const webrpcErrorByCode: {
+    [code: number]: any;
+};
+export type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+export {};

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./builder.gen.js";
+import { Builder as BuilderRpc } from "./builder.gen.js";
+export declare class SequenceBuilderClient extends BuilderRpc {
+    projectAccessKey: string;
+    constructor(projectAccessKey: string, apiUrl?: string);
+    _fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+}