@solutiondesk/legal 0.0.0 → 1.0.0

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,194 @@
 # @solutiondesk/legal
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+Typed client for the [SolutionDesk](https://solutiondesk.io) Legal Hub. Your team keeps the imprint, privacy policy, terms, DPA and sub-processor list in SolutionDesk, with every earlier version. Your website shows them with this package, and your app asks its users to agree to new versions.
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+- 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 versions are ever returned.
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+```bash
+npm install @solutiondesk/legal
+```
 
-## Purpose
+## Quick start
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@solutiondesk/legal`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+```ts
+import { createLegalClient } from "@solutiondesk/legal";
 
-## What is OIDC Trusted Publishing?
+const legal = createLegalClient({ workspace: "acme", lang: "en" });
 
-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.
+const { document } = await legal.getDocument("imprint");
+document.html; // safe to insert as it is
+```
 
-## Setup Instructions
+`workspace` is your workspace's slug, the `acme` in the address shown under **Settings → Legal texts → On your website** (`https://api.solutiondesk.io/v1/legal/acme`).
 
-To properly configure OIDC trusted publishing for this package:
+## Load the texts on the server
 
-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
+Fetch legal texts **on the server or at build time** and keep the last answer. Don't load them in the visitor's browser: your imprint must stay reachable when a script is blocked or SolutionDesk can't be reached for a moment. Answers may be cached for a minute and, while SolutionDesk can't be reached, served from a cache for up to a day (`Cache-Control: public, max-age=60, stale-while-revalidate=600, stale-if-error=86400`). The [webhook](#webhooks-refresh-when-a-version-changes) tells you when to fetch again.
 
-## DO NOT USE THIS PACKAGE
+## What you can read
 
-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
+| Method | API | Returns |
+| --- | --- | --- |
+| `listDocuments({ lang })` | `GET /v1/legal/{workspace}/documents` | Every text with the version that applies today (`current`) and, if one is announced, the next (`upcoming`). |
+| `getDocument(slug, { lang })` | `GET …/documents/{slug}` | The version that applies today in full: `markdown`, `html`, `headings`, `number`, `effectiveAt`, `summary`, `upcoming`. |
+| `listVersions(slug, { lang })` | `GET …/documents/{slug}/versions` | Every published version (earlier, current, announced) with `status` and, for earlier ones, `until`. Only while **Show earlier versions on your website** is on. |
+| `getVersion(slug, number, { lang })` | `GET …/documents/{slug}/versions/{number}` | One version in full: the current one, the announced one, or an earlier one (when earlier versions are shown). |
+| `getSubprocessors({ lang })` | `GET …/subprocessors` | The sub-processor list in force and what the announced list changes (`upcoming.changes`: `added`, `removed`, `changed`). |
+| `getPreview(token, { lang })` | `GET …/preview?token=` | Any version, drafts too, for your preview route. Never cached by the API. |
 
-## More Information
+Which version applies is decided by its date: the highest number whose date has come. A version announced for next month shows up in `upcoming` until that day, then it is the current one, without anyone pressing a button.
 
-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)
+`html` is safe to insert as it is: no scripts, no images, and links only to web addresses, `mailto:`, paths on your site and anchors. Headings carry `id`s for a table of contents. An unknown slug, a workspace without legal texts and a text without a published version all answer `404`, on purpose indistinguishable. Sub-processors your team marked as not public are left out.
 
+## Example: the imprint in Next.js (App Router)
+
+```tsx
+// app/[lang]/legal/[slug]/page.tsx
+import { createLegalClient, SolutionDeskError } from "@solutiondesk/legal";
+import { notFound } from "next/navigation";
+
+const legal = createLegalClient({ workspace: "acme" });
+
+export default async function LegalPage({ params }: { params: Promise<{ lang: string; slug: string }> }) {
+  const { lang, slug } = await params;
+  try {
+    const { document } = await legal.getDocument(
+      slug,
+      { lang },
+      { fetchOptions: { next: { tags: ["legal"], revalidate: 3600 } } },
+    );
+    return (
+      <article lang={document.locale}>
+        <h1>{document.title}</h1>
+        <div dangerouslySetInnerHTML={{ __html: document.html }} />
+        <p>Version {document.number}, in force since {document.effectiveAt?.slice(0, 10)}</p>
+        {document.upcoming && (
+          <p>From {document.upcoming.effectiveAt.slice(0, 10)}: {document.upcoming.summary}</p>
+        )}
+      </article>
+    );
+  } catch (error) {
+    if (error instanceof SolutionDeskError && error.isNotFound) notFound();
+    throw error;
+  }
+}
+```
+
+With Astro (or any static site generator), fetch at build time and rebuild when the webhook arrives:
+
+```astro
 ---
+// src/pages/imprint.astro
+import { createLegalClient } from "@solutiondesk/legal";
+const legal = createLegalClient({ workspace: "acme", lang: "de" });
+const { document } = await legal.getDocument("imprint");
+---
+<article lang={document.locale} set:html={document.html} />
+```
+
+## Webhooks: refresh when a version changes
+
+Under **Settings → Legal texts → On your website** set **Tell your website about changes** to a URL on your site and copy the signing secret (shown once). SolutionDesk then `POST`s whenever readers would see something different, and when someone agrees to a text:
+
+```ts
+// app/api/solutiondesk/legal/route.ts (Next.js)
+import { isAcceptanceRecorded, parseLegalWebhook } from "@solutiondesk/legal";
+import { revalidateTag } from "next/cache";
+
+export async function POST(request: Request) {
+  const body = await parseLegalWebhook(
+    process.env.SOLUTIONDESK_LEGAL_WEBHOOK_SECRET!,
+    await request.text(), // the raw body, exactly as received
+    request.headers.get("x-solutiondesk-signature"),
+  );
+  if (!body) return new Response("Invalid signature", { status: 401 });
+
+  if (isAcceptanceRecorded(body)) {
+    // Someone agreed: body.acceptance.externalId (your user id), .company, .channel, .acceptedAt
+    await markAgreed(body.acceptance.externalId, body.document, body.number);
+  } else if (body.event !== "ping") {
+    revalidateTag("legal"); // version.published, version.effective, version.withdrawn
+  }
+  return new Response(null, { status: 204 });
+}
+```
+
+| `event` | When |
+| --- | --- |
+| `version.published` | a new version was published, also one that only applies later (it shows up in `upcoming`) |
+| `version.effective` | a version applies from now on |
+| `version.withdrawn` | an announced version was withdrawn |
+| `acceptance.recorded` | someone agreed to a version (`acceptance` names who, in your ids); `locales` is empty |
+| `ping` | **Send a test** |
+
+`parseLegalWebhook` returns `null` for a wrong secret, a changed body, a malformed header or a signature older than five minutes. If you only need the check, use `verifyWebhookSignature(secret, rawBody, header)`, which resolves to `true` or `false`. It uses Web Crypto. On Node 18 pass `{ crypto: require("node:crypto").webcrypto }` as the fourth argument; Node 19 and later need nothing. Answer with a `2xx` status; anything else is retried, up to five attempts in all.
+
+## Agreement in your app (server only, API key)
+
+When a text needs agreement (typically your terms), ask which versions a user still has to agree to, show your own dialog, and report the click:
+
+```ts
+// Server only — never ship the API key to a browser.
+import { createLegalHostClient } from "@solutiondesk/legal";
+
+const host = createLegalHostClient({ apiKey: process.env.SOLUTIONDESK_API_KEY! });
+
+const { pending } = await host.pending({ externalId: "user-42", lang: "en" });
+// [{ document: "terms", number: 3, title, summary, url, inForce, effectiveAt, locale, companyExternalId }]
+
+// … the user clicked "I agree" in your dialog:
+const { created, acceptance } = await host.recordAcceptance({
+  externalId: "user-42",
+  document: "terms",
+  number: 3,
+  acceptedAt: new Date().toISOString(),
+  ip: "203.0.113.7",
+  userAgent: request.headers.get("user-agent") ?? undefined,
+});
+```
+
+These call `GET /v1/integration/legal/pending` and `POST /v1/integration/legal/acceptances` with `Authorization: Bearer <apiKey>` (create the key under **Settings → API keys**).
+
+- Agreement has to be active: no pre-ticked box; closing the dialog is not agreeing. Report only a real click.
+- Reporting the same agreement again is harmless (`created: false`).
+- For texts agreed per company by an administrator, send `companyExternalId`. For a user you haven't synced yet, also send `email` and `name`, and they are created on the way.
+- An unknown user (without `email`/`name`), document or version is a `404`; a version that isn't open for the user is a `409`; a time in the future or before publication is a `400`.
+
+## Languages
+
+Pass `lang` to the client (default for every call) or per call. You get exactly that language if the text exists in it, otherwise the same language of another region (`de-AT` → `de`), otherwise the main language. `locale` always says which language the text is really in and `languages` lists every language it exists in; use `locale` for the page's `lang` attribute and `hreflang`.
+
+## Caching and ETags
+
+Every public answer carries an `ETag`. With `etagCache: true` the client sends `If-None-Match` and returns the remembered body on a `304`:
+
+```ts
+const legal = createLegalClient({ workspace: "acme", etagCache: true }); // or your own Map
+```
+
+Per call, `fetchOptions` goes to `fetch` unchanged, for your framework's caching (`{ next: { tags: ["legal"] } }`) or `{ cache: "no-store" }` for previews. Integration calls are never cached.
+
+## Errors
+
+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` (`429`) are shortcuts. Each public address may be asked 600 times a minute per IP address, the preview 60 times.
+
+## Options
+
+```ts
+createLegalClient({
+  workspace: "acme", // required
+  lang: "en",
+  baseUrl: "https://api.solutiondesk.io",
+  fetch: customFetch,
+  headers: {},
+  etagCache: true,
+});
+```
+
+Every method also takes request options as its last argument: `{ signal, headers, fetchOptions }`.
+
+## License
 
-**Maintained for OIDC setup purposes only**
+MIT © wemogy GmbH

package/dist/index.cjs

@@ -0,0 +1,309 @@
+'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: "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 body = parseBody(await response.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/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 createLegalClient(options) {
+  const workspace = required(options.workspace, "workspace");
+  const http = createHttp(options);
+  const base = `/legal/${seg(workspace)}`;
+  const langOf = (params) => ({ lang: params?.lang ?? options.lang });
+  const get = (path, query, o) => http.request({ method: "GET", path: `${base}${path}`, query, options: o });
+  return {
+    workspace,
+    listDocuments: async (params, o) => get("/documents", langOf(params), o),
+    getDocument: async (slug, params, o) => get(`/documents/${seg(required(slug, "slug"))}`, langOf(params), o),
+    listVersions: async (slug, params, o) => get(`/documents/${seg(required(slug, "slug"))}/versions`, langOf(params), o),
+    getVersion: async (slug, number, params, o) => {
+      if (!Number.isInteger(number) || number < 1) {
+        throw new TypeError("SolutionDesk: `number` must be a positive whole number.");
+      }
+      return get(
+        `/documents/${seg(required(slug, "slug"))}/versions/${seg(number)}`,
+        langOf(params),
+        o
+      );
+    },
+    getSubprocessors: async (params, o) => get("/subprocessors", langOf(params), o),
+    getPreview: async (token, params, o) => get("/preview", { token: required(token, "token"), ...langOf(params) }, o)
+  };
+}
+function createLegalHostClient(options) {
+  const apiKey = required(options.apiKey, "apiKey");
+  const http = createHttp({ ...options, etagCache: false });
+  return {
+    pending: async (params, o) => http.request({
+      method: "GET",
+      path: "/integration/legal/pending",
+      query: { externalId: required(params.externalId, "externalId"), lang: params.lang },
+      apiKey,
+      options: o
+    }),
+    recordAcceptance: async (input, o) => http.request({
+      method: "POST",
+      path: "/integration/legal/acceptances",
+      body: input,
+      apiKey,
+      options: o
+    })
+  };
+}
+function parseLegalWebhook(secret, rawBody, signatureHeader, options) {
+  return parseWebhook(secret, rawBody, signatureHeader, options);
+}
+function isAcceptanceRecorded(body) {
+  return body.event === "acceptance.recorded" && !!body.acceptance && body.document !== null;
+}
+
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.EVENT_HEADER = EVENT_HEADER;
+exports.SIGNATURE_HEADER = SIGNATURE_HEADER;
+exports.SolutionDeskError = SolutionDeskError;
+exports.createLegalClient = createLegalClient;
+exports.createLegalHostClient = createLegalHostClient;
+exports.createMemoryEtagCache = createMemoryEtagCache;
+exports.isAcceptanceRecorded = isAcceptanceRecorded;
+exports.parseLegalWebhook = parseLegalWebhook;
+exports.verifyWebhookSignature = verifyWebhookSignature;