@solutiondesk/events 0.0.0 → 1.0.0-69d9f69

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wemogy GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,45 +1,196 @@
 # @solutiondesk/events
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+Typed client for [SolutionDesk](https://solutiondesk.io) event pages. Show your workspace's events on your own website, build your own event page and registration form, show event announcements, and register signed-in users from your server.
+
+- No dependencies, ESM and CommonJS, full TypeScript types.
+- Runs wherever `fetch` does: Node.js 18+, Deno, Bun, edge runtimes and browsers.
+- Reading needs no key: only published events are ever returned.
+
+```bash
+npm install @solutiondesk/events
+```
+
+The guide [Events on your website](https://help.solutiondesk.io/docs/team/events-embedding) explains the API behind this package and where to set it up in SolutionDesk; the [Host API](https://help.solutiondesk.io/docs/team/host-api) covers the calls that need an API key.
+
+## Quick start
+
+```ts
+import { createEventsClient } from "@solutiondesk/events";
+
+const events = createEventsClient({ workspace: "acme", lang: "en" });
+
+const { events: upcoming } = await events.listEvents();
+const { event } = await events.getEvent("kundentag-2026");
+```
+
+`workspace` is your workspace's slug, as in the app's URL.
+
+## What you can do
+
+| Method | API | Returns |
+| --- | --- | --- |
+| `listEvents({ when, lang })` | `GET /v1/event-pages/{workspace}` | Published events that haven't ended, soonest first; `when: "past"` for the ended ones, latest first. At most 100. Invite-only events are never listed. |
+| `getEvent(slug, { invite, lang })` | `GET /v1/event-pages/{workspace}/{event}` | Everything on the event page: texts, times, location, images, programme (`sessions`), the registration `form` and whether registration is open. |
+| `register(slug, input)` | `POST /v1/event-pages/{workspace}/{event}/registrations` | A registration as the public form sends it; the person confirms by email. |
+| `getAnnouncements({ event, visitor, lang })` | `GET /v1/event-pages/{workspace}/announcement` | The event announcements for your website (bar or window), soonest event first. |
+| `dismissAnnouncement({ event, visitor, round })` | `POST /v1/event-pages/{workspace}/announcement/dismiss` | Remembers that a signed-in visitor closed an announcement. |
+| `imageUrl(url, width)` | | An event image at the next offered width up (320, 640, 960, 1280, 1920). |
+
+An unknown workspace, a workspace without events and an unpublished event all answer `404`. Times are ISO 8601 in UTC; show them in the event's `timeZone`. `description` is safe HTML (paragraphs, headings, lists, links, emphasis), `descriptionText` the same as plain text. Online events never expose their link here — it's sent after registering.
+
+## Example: event page with registration (Next.js App Router)
+
+Render the event on the server:
+
+```tsx
+// app/events/[slug]/page.tsx
+import { createEventsClient, SolutionDeskError } from "@solutiondesk/events";
+import { notFound } from "next/navigation";
+import { RegistrationForm } from "./registration-form";
+
+const events = createEventsClient({ workspace: "acme", lang: "en" });
+
+export default async function EventPage({ params }: { params: Promise<{ slug: string }> }) {
+  const { slug } = await params;
+  try {
+    const { event } = await events.getEvent(slug, {}, { fetchOptions: { next: { revalidate: 60 } } });
+    return (
+      <main lang={event.locale}>
+        <h1>{event.title}</h1>
+        {event.description && <div dangerouslySetInnerHTML={{ __html: event.description }} />}
+        {event.registration.open ? (
+          <RegistrationForm slug={event.slug} form={event.form} locale={event.locale} />
+        ) : (
+          <p>Registration is {event.registration.reason}.</p>
+        )}
+      </main>
+    );
+  } catch (error) {
+    if (error instanceof SolutionDeskError && error.isNotFound) notFound();
+    throw error;
+  }
+}
+```
+
+and register from the visitor's browser, with the two anti-bot fields:
+
+```tsx
+// app/events/[slug]/registration-form.tsx
+"use client";
+import { createEventsClient, type FormDefinition, SolutionDeskError } from "@solutiondesk/events";
+import { useRef, useState } from "react";
+
+const events = createEventsClient({ workspace: "acme" });
+
+export function RegistrationForm(props: { slug: string; form: FormDefinition; locale: string }) {
+  const openedAt = useRef(Date.now());
+  const [message, setMessage] = useState("");
+
+  async function onSubmit(e: React.FormEvent<HTMLFormElement>) {
+    e.preventDefault();
+    const data = new FormData(e.currentTarget);
+    try {
+      await events.register(props.slug, {
+        firstName: String(data.get("firstName")),
+        lastName: String(data.get("lastName")),
+        email: String(data.get("email")),
+        answers: {}, // your questions from props.form.fields, keyed by field id
+        locale: props.locale,
+        website: String(data.get("website") ?? ""), // honeypot: hidden, must stay empty
+        elapsedMs: Date.now() - openedAt.current, // under 1.5 s counts as a bot
+      });
+      setMessage("Check your email to confirm.");
+    } catch (error) {
+      setMessage(error instanceof SolutionDeskError ? error.message : "Please try again.");
+    }
+  }
+
+  return (
+    <form onSubmit={onSubmit}>
+      <input name="firstName" required />
+      <input name="lastName" required />
+      <input name="email" type="email" required />
+      {/* Hidden from people; bots fill it in. */}
+      <input name="website" tabIndex={-1} autoComplete="off" style={{ display: "none" }} />
+      <button type="submit">Register</button>
+      <p aria-live="polite">{message}</p>
+    </form>
+  );
+}
+```
+
+### Registration rules
+
+- **Where from:** browsers can register only from the websites listed under **Event settings → Your websites** (CORS); other websites can read but not register. A request from your server works too, but all of them then count against your server's IP address (see limits).
+- **Anti-bot fields:** `website` is a honeypot, the value of a hidden input people never see, so it must stay empty. `elapsedMs` is how long the form was open. A filled honeypot or under 1500 ms is dropped silently: the answer is still `check_email`, nothing is stored. Leave `elapsedMs` out if you don't measure it.
+- **The answer** is always `{ result: "check_email" }`: the person confirms by email. Whether the address was new or already registered stays private.
+- **Answers** are keyed by the form field `id`: text for `text`, `textarea`, `email` and `phone`, a number for `number`, `YYYY-MM-DD` for `date`, the option `id` for `select`, a list of option ids for `multiselect`, a list of session ids for `sessions`, `true` for a ticked `checkbox`, `consent` or `newsletter`. Send `company` / `jobTitle` when the form asks for them (`askCompany`, `askJobTitle`); they are required when `companyRequired` / `jobTitleRequired` say so.
+- **Invitations:** for an invitation link, pass its token as `getEvent(slug, { invite })` and as `invite` in the registration.
+- **Wrong input** rejects with a `SolutionDeskError` with status `400`, `message` and `fields` (field id → message), ready to show next to the inputs.
+- **Limits:** reading 120 requests a minute per IP address; registering 10 in 10 minutes per IP address and 3 an hour per email address. Over the limit: `429`.
+
+## Registering signed-in users from your server (API key)
+
+When someone is signed in to your product, your server can register them directly. You vouch for the email, so there is no confirmation mail and the registration is placed at once (with the same rules: access, capacity, waiting list, required answers).
+
+```ts
+// Server only — never ship the API key to a browser.
+import { createEventsHostClient } from "@solutiondesk/events";
+
+const host = createEventsHostClient({ apiKey: process.env.SOLUTIONDESK_API_KEY! });
+
+const { result } = await host.register("kundentag-2026", {
+  firstName: "Ada",
+  lastName: "Lovelace",
+  email: "ada@example.com",
+  answers: { diet: "vegetarian" },
+  locale: "en",
+});
+// result: "confirmed" | "pending_approval" | "waitlisted"
+```
+
+This calls `POST /v1/integration/events/{event}/registrations` with `Authorization: Bearer <apiKey>`. Create the key in SolutionDesk under **Settings → API keys** (the raw key is shown once). The person gets a mail with a link to change or cancel.
+
+## Announcements on your website
+
+```ts
+const { announcements } = await events.getAnnouncements({ lang: "en" });
+```
+
+Each announcement has a `style` (`bar` or `modal`), texts, the button's `url` and a `round`. To keep an announcement closed on all of a signed-in user's devices, send `visitor`: a SHA-256 hex digest of your user id. Answers then carry `dismissed`, and `dismissAnnouncement({ event, visitor, round })` stores a close.
+
+## Languages
+
+Pass `lang` to the client (default for every call) or per call (any of the event's languages). Without it, the request's `Accept-Language` header decides (forward your visitor's with `headers`), then the event's main language. Every event carries `locale`, the language of its texts, and `languages`, everything it is offered in (main first, e.g. `[{ code: "en", label: "English" }, { code: "de", label: "Deutsch" }]`). Send `locale` with a registration and the person's mails come in that language.
+
+## Images
+
+`coverImage` and `images` are public addresses cached for a year, with a ready `srcset`, `width`, `height` and `alt`. `imageUrl(url, width)` gives the WebP at the next offered width up, for example for a Next.js custom image loader.
+
+## Caching
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+The event endpoints send no `ETag`, so `etagCache` has no effect here. Cache with your framework instead: every method takes `{ fetchOptions }` as its last argument, which goes to `fetch` unchanged (e.g. Next.js `{ next: { revalidate: 60 } }`).
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+## Errors
 
-## Purpose
+Every failed request rejects with a `SolutionDeskError` with `status` (`0` when no answer arrived), `message` (the API's text), `body`, `url` and, on a `400`, `fields`. `isNotFound` and `isRateLimited` are shortcuts.
+
+## Options
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@solutiondesk/events`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+```ts
+createEventsClient({
+  workspace: "acme", // required
+  lang: "en",
+  baseUrl: "https://api.solutiondesk.io",
+  fetch: customFetch,
+  headers: { "accept-language": visitorLanguages },
+});
+```
+
+Every method also takes request options as its last argument: `{ signal, headers, fetchOptions }`.
 
-## What is OIDC Trusted Publishing?
+`verifyWebhookSignature` and `SolutionDeskError` are exported here too, the same as in `@solutiondesk/blog` and `@solutiondesk/legal`.
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+## License
 
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+MIT © wemogy GmbH

package/dist/index.cjs

@@ -0,0 +1,326 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../sdk-core/src/http.ts
+var DEFAULT_BASE_URL = "https://api.solutiondesk.io";
+var SolutionDeskError = class extends Error {
+  constructor(message, init) {
+    super(message);
+    /** The HTTP status; `0` when no answer arrived (network error, aborted). */
+    __publicField(this, "status");
+    /** The parsed JSON body of the error answer (usually `{ error: string }`), else its text. */
+    __publicField(this, "body");
+    /** The requested URL. */
+    __publicField(this, "url");
+    /** Messages per input field on a `400` (e.g. `{ email: "Enter a valid email address." }`). */
+    __publicField(this, "fields");
+    this.name = "SolutionDeskError";
+    this.status = init.status;
+    this.body = init.body ?? null;
+    this.url = init.url;
+    this.fields = fieldsOf(init.body);
+    if (init.cause !== void 0) {
+      Object.defineProperty(this, "cause", { value: init.cause, enumerable: false });
+    }
+  }
+  /** `404`: unknown workspace, module turned off or unknown item — on purpose indistinguishable. */
+  get isNotFound() {
+    return this.status === 404;
+  }
+  /** `429`: over the rate limit; try again later. */
+  get isRateLimited() {
+    return this.status === 429;
+  }
+};
+function fieldsOf(body) {
+  if (!body || typeof body !== "object") return {};
+  const fields = body.fields;
+  if (!fields || typeof fields !== "object") return {};
+  const out = {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (typeof value === "string") out[key] = value;
+  }
+  return out;
+}
+function messageOf(body, status) {
+  if (body && typeof body === "object") {
+    const { error, message, statusCode } = body;
+    if (typeof statusCode === "number" && typeof message === "string" && message) return message;
+    if (typeof error === "string" && error) return error;
+    if (typeof message === "string" && message) return message;
+    if (Array.isArray(message) && typeof message[0] === "string") return message[0];
+  }
+  if (typeof body === "string" && body.trim() && body.length <= 300) return body.trim();
+  return `SolutionDesk answered ${status}.`;
+}
+function createMemoryEtagCache(maxEntries = 500) {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => entries.get(key),
+    set(key, value) {
+      entries.delete(key);
+      entries.set(key, value);
+      if (entries.size > maxEntries) {
+        const oldest = entries.keys().next().value;
+        if (oldest !== void 0) entries.delete(oldest);
+      }
+    }
+  };
+}
+function queryString(query) {
+  if (!query) return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null || value === "") continue;
+    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  return parts.length ? `?${parts.join("&")}` : "";
+}
+var seg = (value) => encodeURIComponent(String(value));
+function parseBody(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function createHttp(options = {}) {
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "").replace(/\/v1$/, "");
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const cache = options.etagCache === true ? createMemoryEtagCache() : options.etagCache ? options.etagCache : void 0;
+  const url = (path, query) => `${baseUrl}/v1${path}${queryString(query)}`;
+  async function requestWithMeta(req) {
+    if (!fetchImpl) {
+      throw new Error("No global fetch available: pass `fetch` to the client.");
+    }
+    const target = url(req.path, req.query);
+    const headers = {
+      accept: req.accept ?? "application/json",
+      ...options.headers,
+      ...req.options?.headers
+    };
+    if (req.body !== void 0) headers["content-type"] = "application/json";
+    if (req.apiKey) headers.authorization = `Bearer ${req.apiKey}`;
+    const cacheKey = req.method === "GET" && !req.apiKey ? target : void 0;
+    const cached = cacheKey && cache ? cache.get(cacheKey) : void 0;
+    if (cached && !Object.keys(headers).some((h) => h.toLowerCase() === "if-none-match")) {
+      headers["if-none-match"] = cached.etag;
+    }
+    const init = {
+      ...req.options?.fetchOptions,
+      method: req.method,
+      headers
+    };
+    if (req.body !== void 0) init.body = JSON.stringify(req.body);
+    if (req.options?.signal !== void 0) init.signal = req.options.signal;
+    let response;
+    try {
+      response = await fetchImpl(target, init);
+    } catch (cause) {
+      const reason = cause instanceof Error ? cause.message : String(cause);
+      throw new SolutionDeskError(`The request to SolutionDesk failed: ${reason}`, {
+        status: 0,
+        url: target,
+        cause
+      });
+    }
+    const finalUrl = response.url;
+    const meta = {
+      status: response.status,
+      finalUrl: typeof finalUrl === "string" && finalUrl ? finalUrl : null
+    };
+    if (response.status === 304 && cached) {
+      return { data: cached.body, ...meta };
+    }
+    const text = await response.text();
+    const body = response.ok && req.responseType === "text" ? text : parseBody(text);
+    if (!response.ok) {
+      throw new SolutionDeskError(messageOf(body, response.status), {
+        status: response.status,
+        body,
+        url: target
+      });
+    }
+    const etag = response.headers.get("etag");
+    if (cacheKey && cache && etag) cache.set(cacheKey, { etag, body });
+    return { data: body, ...meta };
+  }
+  return {
+    baseUrl,
+    url,
+    requestWithMeta,
+    request: async (req) => (await requestWithMeta(req)).data
+  };
+}
+function required(value, name) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new TypeError(`SolutionDesk: \`${name}\` is required.`);
+  }
+  return value;
+}
+
+// ../sdk-core/src/images.ts
+var IMAGE_WIDTHS = [320, 640, 960, 1280, 1920];
+function imageWidthFor(width) {
+  return IMAGE_WIDTHS.find((w) => w >= width) ?? 1920;
+}
+function imageUrl(url, width) {
+  if (width === void 0) return url;
+  const base = url.replace(/([?&])w=\d+(&|$)/, (_m, sep, end) => end ? sep : "");
+  const join = base.includes("?") ? /[?&]$/.test(base) ? "" : "&" : "?";
+  return `${base}${join}w=${imageWidthFor(width)}`;
+}
+
+// ../sdk-core/src/webhook.ts
+var SIGNATURE_HEADER = "x-solutiondesk-signature";
+var EVENT_HEADER = "x-solutiondesk-event";
+function encoder() {
+  const Encoder = globalThis.TextEncoder;
+  if (!Encoder) throw new Error("TextEncoder is not available in this runtime.");
+  return new Encoder();
+}
+function bytesOf(body) {
+  if (typeof body === "string") return encoder().encode(body);
+  return body instanceof Uint8Array ? body : new Uint8Array(body);
+}
+function webhookBodyText(body) {
+  if (typeof body === "string") return body;
+  const Decoder = globalThis.TextDecoder;
+  if (!Decoder) throw new Error("TextDecoder is not available in this runtime.");
+  return new Decoder().decode(bytesOf(body));
+}
+function hex(buffer) {
+  let out = "";
+  for (const byte of new Uint8Array(buffer)) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function parseHeader(header) {
+  let t = Number.NaN;
+  const signatures = [];
+  for (const part of header.split(",")) {
+    const index = part.indexOf("=");
+    if (index < 0) continue;
+    const key = part.slice(0, index).trim();
+    const value = part.slice(index + 1).trim();
+    if (key === "t" && /^\d{1,12}$/.test(value)) t = Number(value);
+    else if (key === "v1" && /^[0-9a-f]{64}$/i.test(value)) signatures.push(value.toLowerCase());
+  }
+  return Number.isFinite(t) && signatures.length > 0 ? { t, signatures } : null;
+}
+async function verifyWebhookSignature(secret, rawBody, header, options = {}) {
+  if (!secret || !header || header.length > 1e3) return false;
+  const parsed = parseHeader(header);
+  if (!parsed) return false;
+  const now = options.now instanceof Date ? options.now.getTime() : options.now ?? Date.now();
+  const tolerance = options.toleranceSeconds ?? 300;
+  if (Math.abs(now / 1e3 - parsed.t) > tolerance) return false;
+  const subtle = options.crypto?.subtle ?? globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error(
+      "Web Crypto is not available: pass `crypto` (on Node 18: require('node:crypto').webcrypto)."
+    );
+  }
+  const text = encoder();
+  const key = await subtle.importKey(
+    "raw",
+    text.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const prefix = text.encode(`${parsed.t}.`);
+  const body = bytesOf(rawBody);
+  const signed = new Uint8Array(prefix.length + body.length);
+  signed.set(prefix, 0);
+  signed.set(body, prefix.length);
+  const expected = hex(await subtle.sign("HMAC", key, signed));
+  let ok = false;
+  for (const signature of parsed.signatures) ok = constantTimeEqual(expected, signature) || ok;
+  return ok;
+}
+async function parseWebhook(secret, rawBody, header, options = {}) {
+  if (!await verifyWebhookSignature(secret, rawBody, header, options)) return null;
+  try {
+    return JSON.parse(webhookBodyText(rawBody));
+  } catch {
+    return null;
+  }
+}
+
+// src/client.ts
+function createEventsClient(options) {
+  const workspace = required(options.workspace, "workspace");
+  const http = createHttp(options);
+  const base = `/event-pages/${seg(workspace)}`;
+  const langOf = (params) => params?.lang ?? options.lang;
+  return {
+    workspace,
+    listEvents: async (params, requestOptions) => http.request({
+      method: "GET",
+      path: base,
+      query: { when: params?.when, lang: langOf(params) },
+      options: requestOptions
+    }),
+    getEvent: async (slug, params, requestOptions) => http.request({
+      method: "GET",
+      path: `${base}/${seg(required(slug, "slug"))}`,
+      query: { invite: params?.invite, lang: langOf(params) },
+      options: requestOptions
+    }),
+    getAnnouncements: async (params, requestOptions) => http.request({
+      method: "GET",
+      path: `${base}/announcement`,
+      query: { event: params?.event, visitor: params?.visitor, lang: langOf(params) },
+      options: requestOptions
+    }),
+    dismissAnnouncement: async (input, requestOptions) => http.request({
+      method: "POST",
+      path: `${base}/announcement/dismiss`,
+      body: { event: input.event, visitor: input.visitor, round: input.round },
+      options: requestOptions
+    }),
+    register: async (slug, input, requestOptions) => http.request({
+      method: "POST",
+      path: `${base}/${seg(required(slug, "slug"))}/registrations`,
+      body: input,
+      options: requestOptions
+    }),
+    imageUrl
+  };
+}
+function createEventsHostClient(options) {
+  const apiKey = required(options.apiKey, "apiKey");
+  const http = createHttp({ ...options, etagCache: false });
+  return {
+    register: async (slug, input, requestOptions) => http.request({
+      method: "POST",
+      path: `/integration/events/${seg(required(slug, "slug"))}/registrations`,
+      body: input,
+      apiKey,
+      options: requestOptions
+    })
+  };
+}
+
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.EVENT_HEADER = EVENT_HEADER;
+exports.IMAGE_WIDTHS = IMAGE_WIDTHS;
+exports.SIGNATURE_HEADER = SIGNATURE_HEADER;
+exports.SolutionDeskError = SolutionDeskError;
+exports.createEventsClient = createEventsClient;
+exports.createEventsHostClient = createEventsHostClient;
+exports.createMemoryEtagCache = createMemoryEtagCache;
+exports.imageUrl = imageUrl;
+exports.imageWidthFor = imageWidthFor;
+exports.parseWebhook = parseWebhook;
+exports.verifyWebhookSignature = verifyWebhookSignature;