@deadair/sdk 0.7.0

package/dist/index.js

@@ -0,0 +1,3509 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/sdk-options.ts
+var SdkError = class extends Error {
+  static {
+    __name(this, "SdkError");
+  }
+  status;
+  statusText;
+  body;
+  headers;
+  constructor(status, statusText, body, headers) {
+    super(`${status} ${statusText}`), this.status = status, this.statusText = statusText, this.body = body, this.headers = headers;
+    this.name = "SdkError";
+  }
+};
+var bigIntReplacer = /* @__PURE__ */ __name((_, value) => {
+  if (typeof value === "bigint") {
+    return value.toString() + "n";
+  }
+  return value;
+}, "bigIntReplacer");
+var bigIntReviver = /* @__PURE__ */ __name((_, value) => {
+  if (typeof value === "string" && /^-?\d+n$/.test(value)) {
+    return BigInt(value.slice(0, -1));
+  }
+  return value;
+}, "bigIntReviver");
+function readContentType(res) {
+  return res.headers.get("content-type")?.split(";")[0]?.trim() ?? "";
+}
+__name(readContentType, "readContentType");
+function randomRequestId() {
+  if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+__name(randomRequestId, "randomRequestId");
+function createSdkFetch(options) {
+  const getRequestId = options.requestIdFactory ?? randomRequestId;
+  return async (url, init) => {
+    const baseHeaders = typeof options.headers === "function" ? await options.headers() : options.headers ?? {};
+    const res = await fetch(`${options.baseUrl}${url}`, {
+      ...init,
+      headers: {
+        ...baseHeaders,
+        "X-Request-ID": getRequestId(),
+        ...init.headers
+      }
+    });
+    if (!res.ok && !(init.expectStatuses ?? []).includes(res.status)) {
+      const text = await res.text();
+      let body;
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = text;
+      }
+      throw new SdkError(res.status, res.statusText, body, res.headers);
+    }
+    return res;
+  };
+}
+__name(createSdkFetch, "createSdkFetch");
+function buildQueryString(query) {
+  const searchParams = new URLSearchParams();
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v === void 0 || v === null) continue;
+      if (Array.isArray(v)) {
+        for (const item of v) searchParams.append(k, String(item));
+      } else searchParams.set(k, String(v));
+    }
+  }
+  const qs = searchParams.toString();
+  return qs ? `?${qs}` : "";
+}
+__name(buildQueryString, "buildQueryString");
+function buildHeaders(headers) {
+  const out = {};
+  if (headers) {
+    for (const [k, v] of Object.entries(headers)) {
+      if (v === void 0 || v === null) continue;
+      out[k] = Array.isArray(v) ? v.map(String).join(", ") : String(v);
+    }
+  }
+  return out;
+}
+__name(buildHeaders, "buildHeaders");
+function parseBigIntHeader(name, value) {
+  if (/^-?\d+n?$/.test(value)) return BigInt(value.replace(/n$/, ""));
+  throw new Error(`Response header '${name}' is not a bigint: ${JSON.stringify(value)}`);
+}
+__name(parseBigIntHeader, "parseBigIntHeader");
+async function parseJson(res) {
+  return JSON.parse(await res.text());
+}
+__name(parseJson, "parseJson");
+async function parseJsonWithBigInt(res) {
+  return JSON.parse(await res.text(), bigIntReviver);
+}
+__name(parseJsonWithBigInt, "parseJsonWithBigInt");
+
+// src/activity/types/activity.types.ts
+import { Decimal } from "decimal.js";
+import { DateTime } from "luxon";
+Decimal.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function reviveActivityEntry(raw) {
+  const __o0 = raw;
+  __o0["at"] = __dt(__o0["at"], "ActivityEntry.at");
+  return raw;
+}
+__name(reviveActivityEntry, "reviveActivityEntry");
+function reviveActivityPage(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["entries"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveActivityEntry(__a1[__i2]);
+    }
+  }
+  return raw;
+}
+__name(reviveActivityPage, "reviveActivityPage");
+
+// src/activity/activity.client.ts
+var ActivityClient = class {
+  static {
+    __name(this, "ActivityClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name Read activity
+   * @description The feed, newest first, one page at a time
+   */
+  async readActivity(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/activity${qs}`, {
+      method: "GET"
+    });
+    return reviveActivityPage(await parseJson(result));
+  }
+};
+
+// src/art/art.client.ts
+var ArtClient = class {
+  static {
+    __name(this, "ArtClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name Get art
+   * @description The bytes of one cached image
+   */
+  async getArt(id) {
+    const result = await this.fetch(`/art/${encodeURIComponent(id)}`, {
+      method: "GET",
+      expectStatuses: [
+        304
+      ]
+    });
+    switch (result.status) {
+      case 304:
+        return {
+          status: 304
+        };
+      default:
+        return {
+          status: 200,
+          contentType: readContentType(result),
+          data: await result.blob(),
+          headers: {
+            cacheControl: result.headers.get("cache-control") ?? void 0,
+            etag: result.headers.get("etag") ?? void 0
+          }
+        };
+    }
+  }
+};
+
+// src/authentication/types/authentication.types.ts
+import { Decimal as Decimal2 } from "decimal.js";
+import { DateTime as DateTime2 } from "luxon";
+Decimal2.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt2 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime2.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function reviveAuthenticationRegistration(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt2(__o0["expiresAt"], "AuthenticationRegistration.expiresAt");
+  return raw;
+}
+__name(reviveAuthenticationRegistration, "reviveAuthenticationRegistration");
+function reviveOidcLoginStartResponse(raw) {
+  const __o0 = raw;
+  __o0["expires_at"] = __dt2(__o0["expires_at"], "OidcLoginStartResponse.expires_at");
+  return raw;
+}
+__name(reviveOidcLoginStartResponse, "reviveOidcLoginStartResponse");
+function reviveFactorChallengePhoneStartResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt2(__o0["expiresAt"], "FactorChallengePhoneStartResponse.expiresAt");
+  return raw;
+}
+__name(reviveFactorChallengePhoneStartResponse, "reviveFactorChallengePhoneStartResponse");
+function reviveFactorChallengePhoneStartResponseOutput(raw) {
+  const __o0 = raw;
+  __o0["expires_at"] = __dt2(__o0["expires_at"], "FactorChallengePhoneStartResponse.expires_at");
+  return raw;
+}
+__name(reviveFactorChallengePhoneStartResponseOutput, "reviveFactorChallengePhoneStartResponseOutput");
+function reviveFactorChallengeEmailStartResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt2(__o0["expiresAt"], "FactorChallengeEmailStartResponse.expiresAt");
+  return raw;
+}
+__name(reviveFactorChallengeEmailStartResponse, "reviveFactorChallengeEmailStartResponse");
+function reviveFactorChallengeEmailStartResponseOutput(raw) {
+  const __o0 = raw;
+  __o0["expires_at"] = __dt2(__o0["expires_at"], "FactorChallengeEmailStartResponse.expires_at");
+  return raw;
+}
+__name(reviveFactorChallengeEmailStartResponseOutput, "reviveFactorChallengeEmailStartResponseOutput");
+function reviveSessionFactor(raw) {
+  const __o0 = raw;
+  __o0["issuedAt"] = __dt2(__o0["issuedAt"], "SessionFactor.issuedAt");
+  __o0["authenticatedAt"] = __dt2(__o0["authenticatedAt"], "SessionFactor.authenticatedAt");
+  return raw;
+}
+__name(reviveSessionFactor, "reviveSessionFactor");
+function reviveLogin(raw) {
+  const __o0 = raw;
+  __o0["occurredAt"] = __dt2(__o0["occurredAt"], "Login.occurredAt");
+  return raw;
+}
+__name(reviveLogin, "reviveLogin");
+function reviveBaseAuthenticationLoginStartResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt2(__o0["expiresAt"], "BaseAuthenticationLoginStartResponse.expiresAt");
+  return raw;
+}
+__name(reviveBaseAuthenticationLoginStartResponse, "reviveBaseAuthenticationLoginStartResponse");
+function reviveSession(raw) {
+  const __o0 = raw;
+  __o0["issuedAt"] = __dt2(__o0["issuedAt"], "Session.issuedAt");
+  __o0["expiresAt"] = __dt2(__o0["expiresAt"], "Session.expiresAt");
+  __o0["lastAccessedAt"] = __dt2(__o0["lastAccessedAt"], "Session.lastAccessedAt");
+  {
+    const __a1 = __o0["factors"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveSessionFactor(__a1[__i2]);
+    }
+  }
+  return raw;
+}
+__name(reviveSession, "reviveSession");
+function reviveCodeAuthenticationLoginStartResponse(raw) {
+  reviveBaseAuthenticationLoginStartResponse(raw);
+  return raw;
+}
+__name(reviveCodeAuthenticationLoginStartResponse, "reviveCodeAuthenticationLoginStartResponse");
+function reviveLinkAuthenticationLoginStartResponse(raw) {
+  reviveBaseAuthenticationLoginStartResponse(raw);
+  return raw;
+}
+__name(reviveLinkAuthenticationLoginStartResponse, "reviveLinkAuthenticationLoginStartResponse");
+function reviveOidcAuthenticationLoginStartResponse(raw) {
+  reviveBaseAuthenticationLoginStartResponse(raw);
+  return raw;
+}
+__name(reviveOidcAuthenticationLoginStartResponse, "reviveOidcAuthenticationLoginStartResponse");
+function reviveMfaRequiredResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt2(__o0["expiresAt"], "MfaRequiredResponse.expiresAt");
+  return raw;
+}
+__name(reviveMfaRequiredResponse, "reviveMfaRequiredResponse");
+function reviveMfaRequiredResponseOutput(raw) {
+  const __o0 = raw;
+  __o0["expires_at"] = __dt2(__o0["expires_at"], "MfaRequiredResponse.expires_at");
+  return raw;
+}
+__name(reviveMfaRequiredResponseOutput, "reviveMfaRequiredResponseOutput");
+function reviveFidoAuthenticationLoginStartResponse(raw) {
+  reviveBaseAuthenticationLoginStartResponse(raw);
+  return raw;
+}
+__name(reviveFidoAuthenticationLoginStartResponse, "reviveFidoAuthenticationLoginStartResponse");
+function reviveFactorChallengeFidoStartResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt2(__o0["expiresAt"], "FactorChallengeFidoStartResponse.expiresAt");
+  return raw;
+}
+__name(reviveFactorChallengeFidoStartResponse, "reviveFactorChallengeFidoStartResponse");
+function reviveFactorChallengeFidoStartResponseOutput(raw) {
+  const __o0 = raw;
+  __o0["expires_at"] = __dt2(__o0["expires_at"], "FactorChallengeFidoStartResponse.expires_at");
+  return raw;
+}
+__name(reviveFactorChallengeFidoStartResponseOutput, "reviveFactorChallengeFidoStartResponseOutput");
+function reviveStepUpStartResponse(raw) {
+  const __v = [
+    raw
+  ];
+  {
+    const __d0 = __v[0]["result"];
+    if (__d0 === "mfa_required") {
+      reviveMfaRequiredResponse(__v[0]);
+    }
+  }
+  return __v[0];
+}
+__name(reviveStepUpStartResponse, "reviveStepUpStartResponse");
+function reviveStepUpStartResponseOutput(raw) {
+  const __v = [
+    raw
+  ];
+  {
+    const __d0 = __v[0]["result"];
+    if (__d0 === "mfa_required") {
+      reviveMfaRequiredResponseOutput(__v[0]);
+    }
+  }
+  return __v[0];
+}
+__name(reviveStepUpStartResponseOutput, "reviveStepUpStartResponseOutput");
+function reviveAuthenticationTokenResponse(raw) {
+  const __v = [
+    raw
+  ];
+  {
+    const __d0 = __v[0]["result"];
+    if (__d0 === "mfa_required") {
+      reviveMfaRequiredResponse(__v[0]);
+    }
+  }
+  return __v[0];
+}
+__name(reviveAuthenticationTokenResponse, "reviveAuthenticationTokenResponse");
+function reviveAuthenticationTokenResponseOutput(raw) {
+  const __v = [
+    raw
+  ];
+  {
+    const __d0 = __v[0]["result"];
+    if (__d0 === "mfa_required") {
+      reviveMfaRequiredResponseOutput(__v[0]);
+    }
+  }
+  return __v[0];
+}
+__name(reviveAuthenticationTokenResponseOutput, "reviveAuthenticationTokenResponseOutput");
+function reviveAuthenticationLoginStartResponse(raw) {
+  const __v = [
+    raw
+  ];
+  {
+    const __d0 = __v[0]["grant_type"];
+    if (__d0 === "code") {
+      reviveCodeAuthenticationLoginStartResponse(__v[0]);
+    }
+    if (__d0 === "link") {
+      reviveLinkAuthenticationLoginStartResponse(__v[0]);
+    }
+    if (__d0 === "fido") {
+      reviveFidoAuthenticationLoginStartResponse(__v[0]);
+    }
+    if (__d0 === "oidc") {
+      reviveOidcAuthenticationLoginStartResponse(__v[0]);
+    }
+  }
+  return __v[0];
+}
+__name(reviveAuthenticationLoginStartResponse, "reviveAuthenticationLoginStartResponse");
+function reviveFactorChallengeStartResponse(raw) {
+  const __v = [
+    raw
+  ];
+  {
+    const __d0 = __v[0]["method"];
+    if (__d0 === "phone") {
+      reviveFactorChallengePhoneStartResponse(__v[0]);
+    }
+    if (__d0 === "fido") {
+      reviveFactorChallengeFidoStartResponse(__v[0]);
+    }
+    if (__d0 === "email") {
+      reviveFactorChallengeEmailStartResponse(__v[0]);
+    }
+  }
+  return __v[0];
+}
+__name(reviveFactorChallengeStartResponse, "reviveFactorChallengeStartResponse");
+function reviveFactorChallengeStartResponseOutput(raw) {
+  const __v = [
+    raw
+  ];
+  {
+    const __d0 = __v[0]["method"];
+    if (__d0 === "phone") {
+      reviveFactorChallengePhoneStartResponseOutput(__v[0]);
+    }
+    if (__d0 === "fido") {
+      reviveFactorChallengeFidoStartResponseOutput(__v[0]);
+    }
+    if (__d0 === "email") {
+      reviveFactorChallengeEmailStartResponseOutput(__v[0]);
+    }
+  }
+  return __v[0];
+}
+__name(reviveFactorChallengeStartResponseOutput, "reviveFactorChallengeStartResponseOutput");
+
+// src/authentication/types/registration.types.ts
+import { Decimal as Decimal3 } from "decimal.js";
+import { DateTime as DateTime3 } from "luxon";
+Decimal3.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt3 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime3.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function revivePhoneFactorRegistrationResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt3(__o0["expiresAt"], "PhoneFactorRegistrationResponse.expiresAt");
+  __o0["issuedAt"] = __dt3(__o0["issuedAt"], "PhoneFactorRegistrationResponse.issuedAt");
+  return raw;
+}
+__name(revivePhoneFactorRegistrationResponse, "revivePhoneFactorRegistrationResponse");
+function reviveEmailFactorRegistrationResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt3(__o0["expiresAt"], "EmailFactorRegistrationResponse.expiresAt");
+  __o0["issuedAt"] = __dt3(__o0["issuedAt"], "EmailFactorRegistrationResponse.issuedAt");
+  return raw;
+}
+__name(reviveEmailFactorRegistrationResponse, "reviveEmailFactorRegistrationResponse");
+function reviveAuthenticatorFactorRegistrationResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt3(__o0["expiresAt"], "AuthenticatorFactorRegistrationResponse.expiresAt");
+  __o0["issuedAt"] = __dt3(__o0["issuedAt"], "AuthenticatorFactorRegistrationResponse.issuedAt");
+  return raw;
+}
+__name(reviveAuthenticatorFactorRegistrationResponse, "reviveAuthenticatorFactorRegistrationResponse");
+function reviveMfaEnrollPhoneStartResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt3(__o0["expiresAt"], "MfaEnrollPhoneStartResponse.expiresAt");
+  __o0["issuedAt"] = __dt3(__o0["issuedAt"], "MfaEnrollPhoneStartResponse.issuedAt");
+  return raw;
+}
+__name(reviveMfaEnrollPhoneStartResponse, "reviveMfaEnrollPhoneStartResponse");
+function reviveFidoFactorRegistrationResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt3(__o0["expiresAt"], "FidoFactorRegistrationResponse.expiresAt");
+  __o0["issuedAt"] = __dt3(__o0["issuedAt"], "FidoFactorRegistrationResponse.issuedAt");
+  return raw;
+}
+__name(reviveFidoFactorRegistrationResponse, "reviveFidoFactorRegistrationResponse");
+function reviveMfaEnrollFidoStartResponse(raw) {
+  const __o0 = raw;
+  __o0["expiresAt"] = __dt3(__o0["expiresAt"], "MfaEnrollFidoStartResponse.expiresAt");
+  __o0["issuedAt"] = __dt3(__o0["issuedAt"], "MfaEnrollFidoStartResponse.issuedAt");
+  return raw;
+}
+__name(reviveMfaEnrollFidoStartResponse, "reviveMfaEnrollFidoStartResponse");
+function reviveAuthenticationFactorRegistrationResponse(raw) {
+  const __v = [
+    raw
+  ];
+  {
+    const __d0 = __v[0]["method"];
+    if (__d0 === "phone") {
+      revivePhoneFactorRegistrationResponse(__v[0]);
+    }
+    if (__d0 === "email") {
+      reviveEmailFactorRegistrationResponse(__v[0]);
+    }
+    if (__d0 === "authenticator") {
+      reviveAuthenticatorFactorRegistrationResponse(__v[0]);
+    }
+    if (__d0 === "fido") {
+      reviveFidoFactorRegistrationResponse(__v[0]);
+    }
+  }
+  return __v[0];
+}
+__name(reviveAuthenticationFactorRegistrationResponse, "reviveAuthenticationFactorRegistrationResponse");
+
+// src/authentication/authentication.factor.client.ts
+var AuthenticationFactorsClient = class {
+  static {
+    __name(this, "AuthenticationFactorsClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List factors
+   * @description List authentication factors
+   */
+  async listFactors() {
+    const result = await this.fetch(`/auth/factors`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Register factor
+   * @description Register an authentication factor
+   */
+  async registerFactor(body) {
+    const result = await this.fetch(`/auth/factors/register`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return reviveAuthenticationFactorRegistrationResponse(await parseJson(result));
+  }
+  /**
+   * @name Verify factor registration
+   * @description Verify an authentication factor registration
+   */
+  async verifyFactorRegistration(body) {
+    const result = await this.fetch(`/auth/factors/verify`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Start factor challenge
+   * @description Issue a factor verification challenge for a pending MFA round. Authenticated via the short-lived `mfa_challenge_id` in the body, not by session — this is the only /auth/factors/* route that does not require an authenticated session.
+   */
+  async startFactorChallenge(body) {
+    const result = await this.fetch(`/auth/factors/start`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return reviveFactorChallengeStartResponseOutput(await parseJson(result));
+  }
+  /**
+   * @name Start MFA challenge
+   * @description Mint a fresh MFA challenge for the *current* authenticated session so the SPA can satisfy a `step_up_required` denial. Optionally filters eligible factors against an inbound `StepUpRequirement` hint. Returns `enrollment_required` when no enrolled factor matches the requirement so the SPA can route the user into enrollment instead of getting stuck.
+   */
+  async startMFAChallenge(body) {
+    const result = await this.fetch(`/auth/mfa/start`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return reviveStepUpStartResponseOutput(await parseJson(result));
+  }
+  /**
+   * @name Remove factor
+   * @description Remove one of the caller's own factors. Answered only for `authenticator` today, and only after a recent strong-factor verification: the same gate enrolment sits behind once a strong factor exists, so a stolen session cannot quietly switch the second factor off. Removing the last authenticator turns the sign-in challenge off for that account.
+   */
+  async removeFactor(method, methodId) {
+    await this.fetch(`/auth/factors/${encodeURIComponent(method)}/${encodeURIComponent(methodId)}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/authentication/authentication.sessions.client.ts
+var AuthenticationSessionsClient = class {
+  static {
+    __name(this, "AuthenticationSessionsClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name Logout
+   * @description revoke the caller's current session (self sign-out). Deliberately carries no policy gate: signing out must always clear the browser's httpOnly refresh cookie, including for a caller whose access token has already expired. A 401 here would leave a 30-day refresh cookie behind that silently signs the user back in on the next page load. SessionsService revokes the session only when the caller is actually authenticated; an anonymous caller still gets 204 and a cleared cookie.
+   */
+  async logout() {
+    await this.fetch(`/auth/logout`, {
+      method: "POST"
+    });
+  }
+  /**
+   * @name Read session
+   * @description Who the caller is and which platform roles they hold
+   */
+  async readSession() {
+    const result = await this.fetch(`/auth/session`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/authentication/authentication.client.ts
+var AuthenticationClient = class {
+  static {
+    __name(this, "AuthenticationClient");
+  }
+  fetch;
+  factors;
+  sessions;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+    this.factors = new AuthenticationFactorsClient(fetch2);
+    this.sessions = new AuthenticationSessionsClient(fetch2);
+  }
+  /**
+   * @name Request token
+   * @description Request authenticated token
+   */
+  async requestToken(body, options) {
+    const __contentType = options?.contentType ?? "application/x-www-form-urlencoded";
+    const __serialized = __contentType === "application/x-www-form-urlencoded" ? new URLSearchParams(body).toString() : JSON.stringify(body, bigIntReplacer);
+    const result = await this.fetch(`/auth/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": __contentType
+      },
+      body: __serialized
+    });
+    return reviveAuthenticationTokenResponseOutput(await parseJson(result));
+  }
+  /**
+   * @name Register login
+   * @description Register a new login
+   */
+  async registerLogin(body) {
+    const result = await this.fetch(`/auth/login/register`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return reviveAuthenticationRegistration(await parseJson(result));
+  }
+  /**
+   * @name Verify login registration
+   * @description Verify a login registration
+   */
+  async verifyLoginRegistration(body) {
+    const result = await this.fetch(`/auth/login/verify`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Start login
+   * @description Start a password-less login process
+   */
+  async startLogin(body) {
+    const result = await this.fetch(`/auth/login/start`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return reviveAuthenticationLoginStartResponse(await parseJson(result));
+  }
+};
+
+// src/catalog/types/catalog.types.ts
+import { Decimal as Decimal4 } from "decimal.js";
+import { DateTime as DateTime4 } from "luxon";
+Decimal4.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt4 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime4.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function reviveTrackBinding(raw) {
+  const __o0 = raw;
+  if (__o0["missingAt"] != null) {
+    __o0["missingAt"] = __dt4(__o0["missingAt"], "TrackBinding.missingAt");
+  }
+  if (__o0["lastSeenAt"] != null) {
+    __o0["lastSeenAt"] = __dt4(__o0["lastSeenAt"], "TrackBinding.lastSeenAt");
+  }
+  if (__o0["fetchedAt"] != null) {
+    __o0["fetchedAt"] = __dt4(__o0["fetchedAt"], "TrackBinding.fetchedAt");
+  }
+  if (__o0["lastServedAt"] != null) {
+    __o0["lastServedAt"] = __dt4(__o0["lastServedAt"], "TrackBinding.lastServedAt");
+  }
+  if (__o0["nextAttemptAt"] != null) {
+    __o0["nextAttemptAt"] = __dt4(__o0["nextAttemptAt"], "TrackBinding.nextAttemptAt");
+  }
+  return raw;
+}
+__name(reviveTrackBinding, "reviveTrackBinding");
+function reviveTrackAnalysis(raw) {
+  const __o0 = raw;
+  if (__o0["analyzedAt"] != null) {
+    __o0["analyzedAt"] = __dt4(__o0["analyzedAt"], "TrackAnalysis.analyzedAt");
+  }
+  if (__o0["failedAt"] != null) {
+    __o0["failedAt"] = __dt4(__o0["failedAt"], "TrackAnalysis.failedAt");
+  }
+  return raw;
+}
+__name(reviveTrackAnalysis, "reviveTrackAnalysis");
+function reviveTrackPlay(raw) {
+  const __o0 = raw;
+  __o0["airedAt"] = __dt4(__o0["airedAt"], "TrackPlay.airedAt");
+  return raw;
+}
+__name(reviveTrackPlay, "reviveTrackPlay");
+function reviveFactClaim(raw) {
+  const __o0 = raw;
+  if (__o0["lastUsedAt"] != null) {
+    __o0["lastUsedAt"] = __dt4(__o0["lastUsedAt"], "FactClaim.lastUsedAt");
+  }
+  return raw;
+}
+__name(reviveFactClaim, "reviveFactClaim");
+function reviveTrackDetail(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["bindings"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveTrackBinding(__a1[__i2]);
+    }
+  }
+  if (__o0["analysis"] != null) {
+    reviveTrackAnalysis(__o0["analysis"]);
+  }
+  {
+    const __a3 = __o0["plays"];
+    for (let __i4 = 0; __i4 < __a3.length; __i4++) {
+      reviveTrackPlay(__a3[__i4]);
+    }
+  }
+  return raw;
+}
+__name(reviveTrackDetail, "reviveTrackDetail");
+function reviveTrackEnrichmentSource(raw) {
+  const __o0 = raw;
+  __o0["fetchedAt"] = __dt4(__o0["fetchedAt"], "TrackEnrichmentSource.fetchedAt");
+  if (__o0["expiresAt"] != null) {
+    __o0["expiresAt"] = __dt4(__o0["expiresAt"], "TrackEnrichmentSource.expiresAt");
+  }
+  return raw;
+}
+__name(reviveTrackEnrichmentSource, "reviveTrackEnrichmentSource");
+function reviveArtistEnrichmentSource(raw) {
+  const __o0 = raw;
+  __o0["fetchedAt"] = __dt4(__o0["fetchedAt"], "ArtistEnrichmentSource.fetchedAt");
+  if (__o0["expiresAt"] != null) {
+    __o0["expiresAt"] = __dt4(__o0["expiresAt"], "ArtistEnrichmentSource.expiresAt");
+  }
+  return raw;
+}
+__name(reviveArtistEnrichmentSource, "reviveArtistEnrichmentSource");
+function reviveAlbumEnrichmentSource(raw) {
+  const __o0 = raw;
+  __o0["fetchedAt"] = __dt4(__o0["fetchedAt"], "AlbumEnrichmentSource.fetchedAt");
+  if (__o0["expiresAt"] != null) {
+    __o0["expiresAt"] = __dt4(__o0["expiresAt"], "AlbumEnrichmentSource.expiresAt");
+  }
+  return raw;
+}
+__name(reviveAlbumEnrichmentSource, "reviveAlbumEnrichmentSource");
+function reviveTrackEnrichmentDetail(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["sources"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveTrackEnrichmentSource(__a1[__i2]);
+    }
+  }
+  {
+    const __a3 = __o0["claims"];
+    for (let __i4 = 0; __i4 < __a3.length; __i4++) {
+      reviveFactClaim(__a3[__i4]);
+    }
+  }
+  return raw;
+}
+__name(reviveTrackEnrichmentDetail, "reviveTrackEnrichmentDetail");
+function reviveArtistEnrichmentDetail(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["sources"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveArtistEnrichmentSource(__a1[__i2]);
+    }
+  }
+  {
+    const __a3 = __o0["claims"];
+    for (let __i4 = 0; __i4 < __a3.length; __i4++) {
+      reviveFactClaim(__a3[__i4]);
+    }
+  }
+  return raw;
+}
+__name(reviveArtistEnrichmentDetail, "reviveArtistEnrichmentDetail");
+function reviveAlbumEnrichmentDetail(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["sources"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveAlbumEnrichmentSource(__a1[__i2]);
+    }
+  }
+  {
+    const __a3 = __o0["claims"];
+    for (let __i4 = 0; __i4 < __a3.length; __i4++) {
+      reviveFactClaim(__a3[__i4]);
+    }
+  }
+  return raw;
+}
+__name(reviveAlbumEnrichmentDetail, "reviveAlbumEnrichmentDetail");
+
+// src/catalog/catalog.client.ts
+var CatalogClient = class {
+  static {
+    __name(this, "CatalogClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List artists
+   * @description Every artist the station has ingested, ordered by name
+   */
+  async listArtists(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/catalog/artists${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get artist
+   * @description One artist. 404s on an id that was merged away, since reads never return merged rows
+   */
+  async getArtist(id) {
+    const result = await this.fetch(`/catalog/artists/${encodeURIComponent(id)}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get artist enrichment
+   * @description What every enrichment provider said about this artist, and when each of them said it
+   */
+  async getArtistEnrichment(id) {
+    const result = await this.fetch(`/catalog/artists/${encodeURIComponent(id)}/enrichment`, {
+      method: "GET"
+    });
+    return reviveArtistEnrichmentDetail(await parseJson(result));
+  }
+  /**
+   * @name List artist albums
+   * @description The albums credited to one artist
+   */
+  async listArtistAlbums(id, query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/catalog/artists/${encodeURIComponent(id)}/albums${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Rate artist
+   * @description What the station thinks of this artist. A dislike here excludes every record they are credited on
+   */
+  async rateArtist(id, body) {
+    const result = await this.fetch(`/catalog/artists/${encodeURIComponent(id)}/rating`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /** @name List albums */
+  async listAlbums(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/catalog/albums${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /** @name Get album */
+  async getAlbum(id) {
+    const result = await this.fetch(`/catalog/albums/${encodeURIComponent(id)}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get album enrichment
+   * @description The record's own enrichment: the label, pressing and cover belong to the release, not to a track on it
+   */
+  async getAlbumEnrichment(id) {
+    const result = await this.fetch(`/catalog/albums/${encodeURIComponent(id)}/enrichment`, {
+      method: "GET"
+    });
+    return reviveAlbumEnrichmentDetail(await parseJson(result));
+  }
+  /**
+   * @name List album tracks
+   * @description One album's tracks
+   */
+  async listAlbumTracks(id, query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/catalog/albums/${encodeURIComponent(id)}/tracks${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Rate album
+   * @description What the station thinks of this record. A dislike here excludes every track on it
+   */
+  async rateAlbum(id, body) {
+    const result = await this.fetch(`/catalog/albums/${encodeURIComponent(id)}/rating`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get track
+   * @description One record and everything it has accumulated: its copies, its bytes, its measurement, what it has aired
+   */
+  async getTrack(id) {
+    const result = await this.fetch(`/catalog/tracks/${encodeURIComponent(id)}`, {
+      method: "GET"
+    });
+    return reviveTrackDetail(await parseJson(result));
+  }
+  /**
+   * @name Clear track audio
+   * @description Drop the station's own copies of this record. The next play fetches them again
+   */
+  async clearTrackAudio(id) {
+    const result = await this.fetch(`/catalog/tracks/${encodeURIComponent(id)}/audio`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Clear track analysis
+   * @description Forget the measurement, so the walk takes it again
+   */
+  async clearTrackAnalysis(id) {
+    const result = await this.fetch(`/catalog/tracks/${encodeURIComponent(id)}/analysis`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Retry track audio
+   * @description Try this record's copies again now, rather than when the backoff says
+   */
+  async retryTrackAudio(id) {
+    const result = await this.fetch(`/catalog/tracks/${encodeURIComponent(id)}/retry`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Offer track copies again
+   * @description Put copies a provider refused back on offer, and clear their backoff so they are tried now
+   */
+  async offerTrackCopiesAgain(id) {
+    const result = await this.fetch(`/catalog/tracks/${encodeURIComponent(id)}/offer`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get track enrichment
+   * @description What the providers said about one recording, including everything no canonical column holds
+   */
+  async getTrackEnrichment(id) {
+    const result = await this.fetch(`/catalog/tracks/${encodeURIComponent(id)}/enrichment`, {
+      method: "GET"
+    });
+    return reviveTrackEnrichmentDetail(await parseJson(result));
+  }
+  /**
+   * @name Clear track enrichment
+   * @description Forget what the providers said, so the enrichment pass asks again
+   */
+  async clearTrackEnrichment(id, query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/catalog/tracks/${encodeURIComponent(id)}/enrichment${qs}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name List tracks
+   * @description Every track, flat. The only way to answer "do we have this song?" without knowing its artist
+   */
+  async listTracks(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/catalog/tracks${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Rate track
+   * @description What the station thinks of this song, which is the narrowest thing an opinion can be about
+   */
+  async rateTrack(id, body) {
+    const result = await this.fetch(`/catalog/tracks/${encodeURIComponent(id)}/rating`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/charts/charts.client.ts
+var ChartsClient = class {
+  static {
+    __name(this, "ChartsClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List charts
+   * @description Every chart every installed chart plugin currently offers
+   */
+  async listCharts() {
+    const result = await this.fetch(`/charts`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Read chart
+   * @description One chart's records, ranked
+   */
+  async readChart(id, query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/charts/${encodeURIComponent(id)}${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/director/director.client.ts
+var DirectorClient = class {
+  static {
+    __name(this, "DirectorClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List clock bands
+   * @description Every band on this station's clock, including the ones switched off, in the operator's own order
+   */
+  async listClockBands() {
+    const result = await this.fetch(`/clock/bands`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Create clock band
+   * @description Adds a band. It claims its first boundary on the next commit pass
+   */
+  async createClockBand(body) {
+    const result = await this.fetch(`/clock/bands`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Update clock band
+   * @description Rewrites one band. Breaks it has already planted stay where they are: the running order is the memory
+   */
+  async updateClockBand(id, body) {
+    const result = await this.fetch(`/clock/bands/${encodeURIComponent(id)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Delete clock band
+   * @description Removes a band, which costs it the boundaries it had not claimed yet and nothing else
+   */
+  async deleteClockBand(id) {
+    const result = await this.fetch(`/clock/bands/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get station air
+   * @description What the station is airing, and whether it is driving at all
+   */
+  async getStationAir() {
+    const result = await this.fetch(`/director/air`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Put the station on air
+   * @description Puts the station on air, building the running order from a playlist read at this moment. What is playing finishes: changing the programming is not a reason to cut a listener off mid-track
+   */
+  async putTheStationOnAir(body) {
+    const result = await this.fetch(`/director/air`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Set the air mode
+   * @description Changes what puts the station on air: only while somebody is listening, or whenever there is a programme. Takes effect at once rather than at the next boundary
+   */
+  async setTheAirMode(body) {
+    const result = await this.fetch(`/director/air`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get the running order
+   * @description The live running order, item by item, each saying where it has got to
+   */
+  async getTheRunningOrder() {
+    const result = await this.fetch(`/director/air/order`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Recast the broadcast
+   * @description Changes who is presenting this broadcast. Breaks already written for it in the outgoing character are written again in the new one
+   */
+  async recastTheBroadcast(body) {
+    const result = await this.fetch(`/director/air/persona`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Extend the running order
+   * @description Queues a refill and returns at once. Generating a set walks the catalog, and an operator pressing a button should not be held open through it
+   */
+  async extendTheRunningOrder(body) {
+    await this.fetch(`/director/air/extend`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+  }
+  /**
+   * @name Replan the running order
+   * @description Queues a fresh set for everything the player is not already holding, and swaps it in once it exists. The old tail keeps playing until then, because emptying the running order first would take the station off air while the model was still choosing
+   */
+  async replanTheRunningOrder(body) {
+    await this.fetch(`/director/air/replan`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+  }
+  /**
+   * @name Hold the station against the schedule
+   * @description Holds the running order against the schedule, so a block boundary does not take back what an operator put on. A takeover is otherwise stamped with whichever slot was in force and is replaced when that block ends, which is correct and gives nobody any warning
+   */
+  async holdTheStationAgainstTheSchedule(body) {
+    const result = await this.fetch(`/director/air/hold`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Release the station to the schedule
+   * @description Releases a hold, so the next block boundary changes the station over as it ordinarily would. A station with no hold is unchanged rather than refused
+   */
+  async releaseTheStationToTheSchedule() {
+    const result = await this.fetch(`/director/air/hold`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Shuffle the running order
+   * @description Shuffles the records not yet handed to the player, and plants the breaks again around the new sequence. The head is already in the player's hands and is left alone
+   */
+  async shuffleTheRunningOrder() {
+    const result = await this.fetch(`/director/air/shuffle`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Add a segment to the running order
+   * @description Puts something the station says into the running order. A segment with no audio yet is refused here rather than accepted and skipped when it comes round, so an operator is told why it cannot play
+   */
+  async addASegmentToTheRunningOrder(body) {
+    const result = await this.fetch(`/director/air/segments`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Add a record to the running order
+   * @description Puts a catalog record into the running order. A record whose audio is not local yet is refused here rather than accepted and held or skipped when its slot comes round, so an operator asking for a specific one is told why it cannot play. What makes this worth having on its own is undo: dropping an item only ever marks a segment, but a track is spliced out of the order entirely, so nothing could put one back until this existed
+   */
+  async addARecordToTheRunningOrder(body) {
+    const result = await this.fetch(`/director/air/tracks`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Move a running order item
+   * @description Moves an item. A position already handed to the player is refused rather than clamped
+   */
+  async moveARunningOrderItem(itemId, body) {
+    const result = await this.fetch(`/director/air/items/${encodeURIComponent(itemId)}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Remove a running order item
+   * @description Drops an item that has not been handed to the player yet
+   */
+  async removeARunningOrderItem(itemId) {
+    const result = await this.fetch(`/director/air/items/${encodeURIComponent(itemId)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/history/types/history.types.ts
+import { Decimal as Decimal5 } from "decimal.js";
+import { DateTime as DateTime5 } from "luxon";
+Decimal5.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt5 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime5.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function reviveHistoryEntry(raw) {
+  const __o0 = raw;
+  __o0["airedAt"] = __dt5(__o0["airedAt"], "HistoryEntry.airedAt");
+  return raw;
+}
+__name(reviveHistoryEntry, "reviveHistoryEntry");
+function reviveHistoryPage(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["entries"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveHistoryEntry(__a1[__i2]);
+    }
+  }
+  return raw;
+}
+__name(reviveHistoryPage, "reviveHistoryPage");
+
+// src/history/history.client.ts
+var HistoryClient = class {
+  static {
+    __name(this, "HistoryClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name Read history
+   * @description What the station played, newest first, one page at a time
+   */
+  async readHistory(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/history${qs}`, {
+      method: "GET"
+    });
+    return reviveHistoryPage(await parseJson(result));
+  }
+};
+
+// src/news/news.client.ts
+var NewsClient = class {
+  static {
+    __name(this, "NewsClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List feeds
+   * @description Every feed every installed news plugin currently offers
+   */
+  async listFeeds() {
+    const result = await this.fetch(`/news/feeds`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Read news
+   * @description Published entries, newest first
+   */
+  async readNews(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/news${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/nowplaying/nowplaying.client.ts
+var NowplayingClient = class {
+  static {
+    __name(this, "NowplayingClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name Get now playing
+   * @description What is on air right now. Answers 200 with `onAir: false` when the station is quiet, so a device polling this treats silence as an answer rather than an error
+   */
+  async getNowPlaying() {
+    const result = await this.fetch(`/nowplaying`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/onboarding/onboarding.client.ts
+var OnboardingClient = class {
+  static {
+    __name(this, "OnboardingClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /** @name Get Onboarding Requirements */
+  async getOnboardingRequirements() {
+    const result = await this.fetch(`/onboarding`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /** @name Submit Onboarding Requirement */
+  async submitOnboardingRequirement(body) {
+    const result = await this.fetch(`/onboarding`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/personas/personas.client.ts
+var PersonasClient = class {
+  static {
+    __name(this, "PersonasClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List persona auditions
+   * @description Every audition of this character, newest first, without their breaks
+   */
+  async listPersonaAuditions(id) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/auditions`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Start persona audition
+   * @description Asks the station to put this character through a playlist. It is queued, not written
+   */
+  async startPersonaAudition(id, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/auditions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get persona audition
+   * @description One audition with every break it has written so far, in order
+   */
+  async getPersonaAudition(id, auditionId) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/auditions/${encodeURIComponent(auditionId)}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Cancel persona audition
+   * @description Stops an audition where it stands, keeping the breaks it has already written
+   */
+  async cancelPersonaAudition(id, auditionId) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/auditions/${encodeURIComponent(auditionId)}/cancel`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name List personas
+   * @description Every persona this station has, oldest first
+   */
+  async listPersonas() {
+    const result = await this.fetch(`/personas`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Create persona
+   * @description Writes a new persona. It is not put on air by creating it
+   */
+  async createPersona(body) {
+    const result = await this.fetch(`/personas`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Generate persona
+   * @description Turns a description of a character into a whole persona, checked against its own sample lines and handed back unsaved
+   */
+  async generatePersona(body) {
+    const result = await this.fetch(`/personas/generate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Restore station personas
+   * @description Writes back whichever of the station's own personas this station is missing, touching nothing it already has and putting nothing on air
+   */
+  async restoreStationPersonas() {
+    const result = await this.fetch(`/personas/restore`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Export personas
+   * @description Every character this station holds, as one file
+   */
+  async exportPersonas() {
+    const result = await this.fetch(`/personas/export`, {
+      method: "GET"
+    });
+    const data = await parseJson(result);
+    return {
+      data,
+      headers: {
+        contentDisposition: result.headers.get("Content-Disposition") ?? void 0
+      }
+    };
+  }
+  /**
+   * @name Export persona
+   * @description One character, its sheet and its stories, as a file
+   */
+  async exportPersona(id) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/export`, {
+      method: "GET"
+    });
+    const data = await parseJson(result);
+    return {
+      data,
+      headers: {
+        contentDisposition: result.headers.get("Content-Disposition") ?? void 0
+      }
+    };
+  }
+  /**
+   * @name Preview persona import
+   * @description Reads a file and reports what importing it would create, rewrite and skip. Writes nothing
+   */
+  async previewPersonaImport(body) {
+    const result = await this.fetch(`/personas/import/preview`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Import personas
+   * @description Writes a file into this station, merging by key, and answers with what it did
+   */
+  async importPersonas(body) {
+    const result = await this.fetch(`/personas/import`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Update persona
+   * @description Rewrites one persona. An edit to the one on air is heard on the next break
+   */
+  async updatePersona(id, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Delete persona
+   * @description Removes a persona, including the one on air, which leaves the station with none
+   */
+  async deletePersona(id) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Put persona on air
+   * @description Puts this persona on air and takes the previous one off
+   */
+  async putPersonaOnAir(id) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/active`, {
+      method: "PUT"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name List persona notes
+   * @description Everything this character has accumulated, oldest first, in every state
+   */
+  async listPersonaNotes(id) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/notes`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Write persona note
+   * @description Writes a note by hand. An operator's own note is active from the moment it exists; only the distil pass proposes
+   */
+  async writePersonaNote(id, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/notes`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Update persona note
+   * @description Rewrites one note's words, whoever wrote it. Editing what the station proposed is most of the point of the panel
+   */
+  async updatePersonaNote(id, noteId, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/notes/${encodeURIComponent(noteId)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Delete persona note
+   * @description Removes a note outright. Turning down a PROPOSAL is a state rather than this, or the next pass writes it again
+   */
+  async deletePersonaNote(id, noteId) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/notes/${encodeURIComponent(noteId)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Set persona note state
+   * @description Accepts a proposal, turns one down, or rests an active note. Mirrors the lexicon's own state route
+   */
+  async setPersonaNoteState(id, noteId, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/notes/${encodeURIComponent(noteId)}/state`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name List persona stories
+   * @description Every story this character holds, oldest first, in every state
+   */
+  async listPersonaStories(id) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/stories`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Write persona story
+   * @description Writes a story by hand. An operator's own is tellable from the moment it exists; only the enrichment pass proposes
+   */
+  async writePersonaStory(id, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/stories`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Update persona story
+   * @description Rewrites one story's handle and telling, whoever wrote it
+   */
+  async updatePersonaStory(id, storyId, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/stories/${encodeURIComponent(storyId)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Delete persona story
+   * @description Removes a story outright, details and all. Turning down a PROPOSAL is a state rather than this, or the next pass writes it again
+   */
+  async deletePersonaStory(id, storyId) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/stories/${encodeURIComponent(storyId)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Set persona story state
+   * @description Accepts a proposal, turns one down, or takes a story out of the rotation without losing it
+   */
+  async setPersonaStoryState(id, storyId, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/stories/${encodeURIComponent(storyId)}/state`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Add persona story detail
+   * @description Adds one thing to a story that already exists
+   */
+  async addPersonaStoryDetail(id, storyId, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/stories/${encodeURIComponent(storyId)}/details`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Update persona story detail
+   * @description Rewrites one detail's words
+   */
+  async updatePersonaStoryDetail(id, storyId, detailId, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/stories/${encodeURIComponent(storyId)}/details/${encodeURIComponent(detailId)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Delete persona story detail
+   * @description Removes one detail, leaving the story it was hung on alone
+   */
+  async deletePersonaStoryDetail(id, storyId, detailId) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/stories/${encodeURIComponent(storyId)}/details/${encodeURIComponent(detailId)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Set persona story detail state
+   * @description Accepts a proposed detail or turns it down, which has to outlive the pass that proposed it
+   */
+  async setPersonaStoryDetailState(id, storyId, detailId, body) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/stories/${encodeURIComponent(storyId)}/details/${encodeURIComponent(detailId)}/state`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Rehearse persona
+   * @description Writes a talk break under this persona against two fixed invented records, and answers with every writer that was asked
+   */
+  async rehearsePersona(id) {
+    const result = await this.fetch(`/personas/${encodeURIComponent(id)}/rehearse`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/playlists/playlists.client.ts
+var PlaylistsClient = class {
+  static {
+    __name(this, "PlaylistsClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List importable playlists
+   * @description Fans out across every installed plugin that declares AND implements the `catalog` capability
+   */
+  async listImportablePlaylists() {
+    const result = await this.fetch(`/playlists`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get playlist tracks
+   * @description One playlist's tracks from one plugin
+   */
+  async getPlaylistTracks(pluginId, playlistId) {
+    const result = await this.fetch(`/playlists/${encodeURIComponent(pluginId)}/${encodeURIComponent(playlistId)}/tracks`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/playout/playout.client.ts
+var PlayoutClient = class {
+  static {
+    __name(this, "PlayoutClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name Get playout status
+   * @description What the station is playing and what is queued behind it. The console polls this
+   */
+  async getPlayoutStatus() {
+    const result = await this.fetch(`/playout/status`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Play a playlist
+   * @description Loads a plugin playlist into the running order and starts handing it to the player. Replaces whatever was queued; what is on air finishes rather than being cut off
+   */
+  async playAPlaylist(body) {
+    const result = await this.fetch(`/playout/playlist`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Play a chart
+   * @description Builds the running order from a published chart and starts handing it to the player. The same replacement a playlist makes, from a document somebody else ranked
+   */
+  async playAChart(body) {
+    const result = await this.fetch(`/playout/chart`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Skip the current item
+   * @description Ends the item on air so the next one starts immediately. The station owns the decoder, so this lands at once rather than waiting out audio already committed to a player
+   */
+  async skipTheCurrentItem() {
+    const result = await this.fetch(`/playout/skip`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Start playout
+   * @description Puts the station back on air with the running order it already has, picking it up where Stop left it. Distinct from putting a playlist on air, which builds a new broadcast and throws away what was there. Refused when there is nothing left to resume
+   */
+  async startPlayout() {
+    const result = await this.fetch(`/playout/start`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Stop playout
+   * @description Stands the station down: stops what is on air at once and hands the mount back. The running order is LEFT as it is, so `/playout/start` can pick it up where this stopped it. deadair holds the mount on a lease it renews while it has something to play, so stopping goes quiet rather than falling through to a bed nobody programmed
+   */
+  async stopPlayout() {
+    const result = await this.fetch(`/playout/stop`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/plugins/types/plugins.types.ts
+import { Decimal as Decimal6 } from "decimal.js";
+import { DateTime as DateTime6 } from "luxon";
+Decimal6.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt6 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime6.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function revivePluginSummary(raw) {
+  const __o0 = raw;
+  if (__o0["firstEnabledAt"] != null) {
+    __o0["firstEnabledAt"] = __dt6(__o0["firstEnabledAt"], "PluginSummary.firstEnabledAt");
+  }
+  if (__o0["nextProbeAt"] != null) {
+    __o0["nextProbeAt"] = __dt6(__o0["nextProbeAt"], "PluginSummary.nextProbeAt");
+  }
+  return raw;
+}
+__name(revivePluginSummary, "revivePluginSummary");
+function revivePluginImportResult(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["plugins"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      revivePluginSummary(__a1[__i2]);
+    }
+  }
+  return raw;
+}
+__name(revivePluginImportResult, "revivePluginImportResult");
+function revivePluginDetail(raw) {
+  revivePluginSummary(raw);
+  return raw;
+}
+__name(revivePluginDetail, "revivePluginDetail");
+
+// src/plugins/plugins.client.ts
+var PluginsClient = class {
+  static {
+    __name(this, "PluginsClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List plugins
+   * @description Lists every plugin the host knows about
+   */
+  async listPlugins() {
+    const result = await this.fetch(`/plugins`, {
+      method: "GET"
+    });
+    return (await parseJson(result)).map(revivePluginSummary);
+  }
+  /**
+   * @name List plugin grants
+   * @description Every capability an installed plugin is asking the operator for, with the answer so far
+   */
+  async listPluginGrants() {
+    const result = await this.fetch(`/plugins/grants`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Rescan plugins
+   * @description Rescans the mounted plugin directory: registers new plugins, unloads removed ones
+   */
+  async rescanPlugins() {
+    const result = await this.fetch(`/plugins/rescan`, {
+      method: "POST"
+    });
+    return (await parseJson(result)).map(revivePluginSummary);
+  }
+  /**
+   * @name Import plugin
+   * @description Takes a plugin in from the browser as the tarball npm pack writes and puts it in the plugins directory. It lands disabled, and a newer version of an installed plugin replaces the older one
+   */
+  async importPlugin(body) {
+    const result = await this.fetch(`/plugins/import`, {
+      method: "POST",
+      body
+    });
+    return revivePluginImportResult(await parseJson(result));
+  }
+  /**
+   * @name Get plugin
+   * @description One plugin, including its stored non-secret configuration and last error
+   */
+  async getPlugin(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}`, {
+      method: "GET"
+    });
+    return revivePluginDetail(await parseJson(result));
+  }
+  /**
+   * @name Remove plugin
+   * @description Removes a plugin the operator installed: stops it and deletes its folder. Its settings are kept, so importing it again brings them back. A bundled plugin is refused
+   */
+  async removePlugin(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return (await parseJson(result)).map(revivePluginSummary);
+  }
+  /**
+   * @name Update plugin configuration
+   * @description Validates against the plugin's own config schema, encrypts secrets, persists, and reinitializes
+   */
+  async updatePluginConfiguration(id, body) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/config`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return revivePluginDetail(await parseJson(result));
+  }
+  /**
+   * @name Enable plugin
+   * @description Enables a plugin without resubmitting its configuration
+   */
+  async enablePlugin(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/enable`, {
+      method: "POST"
+    });
+    return revivePluginDetail(await parseJson(result));
+  }
+  /**
+   * @name Disable plugin
+   * @description Disables a plugin and tears its instance down, keeping its configuration
+   */
+  async disablePlugin(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/disable`, {
+      method: "POST"
+    });
+    return revivePluginDetail(await parseJson(result));
+  }
+  /**
+   * @name Decide plugin grant
+   * @description Answers one capability this plugin asked for. Takes effect on the next fetch, with no reload
+   */
+  async decidePluginGrant(id, body) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/grants`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Reload plugin
+   * @description Reapplies the plugin's stored configuration: disposes the running instance and initializes it again
+   */
+  async reloadPlugin(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/reload`, {
+      method: "POST"
+    });
+    return revivePluginDetail(await parseJson(result));
+  }
+  /**
+   * @name Test plugin connection
+   * @description Runs the plugin's own `testConnection()` through the invoker
+   */
+  async testPluginConnection(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/test`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Suggest plugin config options
+   * @description Asks the plugin what to offer for its config fields right now, through the invoker
+   */
+  async suggestPluginConfigOptions(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/config/suggestions`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get plugin logs
+   * @description Returns the plugin's buffered log lines at or above the current log level
+   */
+  async getPluginLogs(id, query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/logs${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Download plugin logs
+   * @description Streams the plugin's full retained log as a plain-text attachment
+   */
+  async downloadPluginLogs(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/logs/download`, {
+      method: "GET"
+    });
+    const data = await result.text();
+    return {
+      data,
+      headers: {
+        contentDisposition: result.headers.get("Content-Disposition") ?? void 0
+      }
+    };
+  }
+  /**
+   * @name Set plugin log level
+   * @description Sets the minimum severity the plugin's log store retains going forward
+   */
+  async setPluginLogLevel(id, body) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/logs/level`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return revivePluginDetail(await parseJson(result));
+  }
+  /**
+   * @name Start plugin OAuth authorization
+   * @description Reports where to send the operator for the provider's consent screen
+   */
+  async startPluginOAuthAuthorization(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/oauth/authorize`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Disconnect plugin OAuth
+   * @description Forgets the plugin's stored OAuth tokens and reinitializes it
+   */
+  async disconnectPluginOAuth(id) {
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/oauth`, {
+      method: "DELETE"
+    });
+    return revivePluginDetail(await parseJson(result));
+  }
+  /**
+   * @name Complete plugin OAuth authorization
+   * @description Completes the flow. Anonymous: the provider redirects the browser here with no session of ours
+   */
+  async completePluginOAuthAuthorization(id, query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/plugins/${encodeURIComponent(id)}/oauth/callback${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/productions/types/productions.types.ts
+import { Decimal as Decimal7 } from "decimal.js";
+import { DateTime as DateTime7 } from "luxon";
+Decimal7.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt7 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime7.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function reviveProductionRequest(raw) {
+  const __o0 = raw;
+  if (__o0["scheduledFor"] != null) {
+    __o0["scheduledFor"] = __dt7(__o0["scheduledFor"], "ProductionRequest.scheduledFor");
+  }
+  return raw;
+}
+__name(reviveProductionRequest, "reviveProductionRequest");
+function reviveProduction(raw) {
+  const __o0 = raw;
+  if (__o0["scheduledFor"] != null) {
+    __o0["scheduledFor"] = __dt7(__o0["scheduledFor"], "Production.scheduledFor");
+  }
+  if (__o0["cancelledAt"] != null) {
+    __o0["cancelledAt"] = __dt7(__o0["cancelledAt"], "Production.cancelledAt");
+  }
+  __o0["createdAt"] = __dt7(__o0["createdAt"], "Production.createdAt");
+  return raw;
+}
+__name(reviveProduction, "reviveProduction");
+function reviveProductionList(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["productions"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveProduction(__a1[__i2]);
+    }
+  }
+  return raw;
+}
+__name(reviveProductionList, "reviveProductionList");
+
+// src/productions/productions.client.ts
+var ProductionsClient = class {
+  static {
+    __name(this, "ProductionsClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List productions
+   * @description Everything the station has made or is making, newest first
+   */
+  async listProductions() {
+    const result = await this.fetch(`/productions`, {
+      method: "GET"
+    });
+    return reviveProductionList(await parseJson(result));
+  }
+  /**
+   * @name Request production
+   * @description Asks the station to make one. It is queued, not started
+   */
+  async requestProduction(body) {
+    const result = await this.fetch(`/productions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return reviveProduction(await parseJson(result));
+  }
+  /**
+   * @name Cancel production
+   * @description Stops a production being made, for good
+   */
+  async cancelProduction(id) {
+    const result = await this.fetch(`/productions/${encodeURIComponent(id)}/cancel`, {
+      method: "POST"
+    });
+    return reviveProduction(await parseJson(result));
+  }
+};
+
+// src/render/types/render.types.ts
+import { Decimal as Decimal8 } from "decimal.js";
+import { DateTime as DateTime8 } from "luxon";
+Decimal8.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt8 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime8.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function revivePad(raw) {
+  const __o0 = raw;
+  if (__o0["lastUsedAt"] != null) {
+    __o0["lastUsedAt"] = __dt8(__o0["lastUsedAt"], "Pad.lastUsedAt");
+  }
+  return raw;
+}
+__name(revivePad, "revivePad");
+function reviveScriptAttempt(raw) {
+  const __o0 = raw;
+  __o0["at"] = __dt8(__o0["at"], "ScriptAttempt.at");
+  return raw;
+}
+__name(reviveScriptAttempt, "reviveScriptAttempt");
+function revivePadList(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["pads"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      revivePad(__a1[__i2]);
+    }
+  }
+  return raw;
+}
+__name(revivePadList, "revivePadList");
+function reviveScriptHistoryPage(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["attempts"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveScriptAttempt(__a1[__i2]);
+    }
+  }
+  return raw;
+}
+__name(reviveScriptHistoryPage, "reviveScriptHistoryPage");
+
+// src/render/render.client.ts
+var RenderClient = class {
+  static {
+    __name(this, "RenderClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List segments
+   * @description Everything the station can play that is not a record
+   */
+  async listSegments() {
+    const result = await this.fetch(`/segments`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Create segment
+   * @description Plans something for the station to say, and starts rendering it
+   */
+  async createSegment(body) {
+    const result = await this.fetch(`/segments`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Upload segment
+   * @description Takes a recording in from the browser and puts it in the library, ready to air
+   */
+  async uploadSegment(body) {
+    const result = await this.fetch(`/segments/upload`, {
+      method: "POST",
+      body
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Scan the segment inbox
+   * @description Takes whatever audio is sitting in the inbox directory into the library. Safe to repeat: a segment is identified by its audio, so the same recording arriving twice is one segment
+   */
+  async scanTheSegmentInbox() {
+    const result = await this.fetch(`/segments/scan`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Read script history
+   * @description What the station has written lately, newest first, one page at a time
+   */
+  async readScriptHistory(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/scripts${qs}`, {
+      method: "GET"
+    });
+    return reviveScriptHistoryPage(await parseJson(result));
+  }
+  /**
+   * @name Rate script
+   * @description What the operator thought of this attempt. Nothing acts on it automatically
+   */
+  async rateScript(id, body) {
+    const result = await this.fetch(`/scripts/${encodeURIComponent(id)}/rating`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return reviveScriptAttempt(await parseJson(result));
+  }
+  /**
+   * @name Read script summary
+   * @description Write attempts by outcome, per presenter, over a recent window
+   */
+  async readScriptSummary(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/scripts/summary${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name List voices
+   * @description The voices the station can be asked to speak in
+   */
+  async listVoices() {
+    const result = await this.fetch(`/voices`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get default voice sample
+   * @description A short line spoken in whichever voice the plugin falls back to
+   */
+  async getDefaultVoiceSample() {
+    const result = await this.fetch(`/voices/sample`, {
+      method: "GET",
+      expectStatuses: [
+        304
+      ]
+    });
+    switch (result.status) {
+      case 304:
+        return {
+          status: 304
+        };
+      default:
+        return {
+          status: 200,
+          contentType: readContentType(result),
+          data: await result.blob(),
+          headers: {
+            cacheControl: result.headers.get("cache-control") ?? void 0,
+            etag: result.headers.get("etag") ?? void 0
+          }
+        };
+    }
+  }
+  /**
+   * @name Get voice sample
+   * @description A short line spoken in one voice, so an operator can hear it before choosing it
+   */
+  async getVoiceSample(voiceId) {
+    const result = await this.fetch(`/voices/${encodeURIComponent(voiceId)}/sample`, {
+      method: "GET",
+      expectStatuses: [
+        304
+      ]
+    });
+    switch (result.status) {
+      case 304:
+        return {
+          status: 304
+        };
+      default:
+        return {
+          status: 200,
+          contentType: readContentType(result),
+          data: await result.blob(),
+          headers: {
+            cacheControl: result.headers.get("cache-control") ?? void 0,
+            etag: result.headers.get("etag") ?? void 0
+          }
+        };
+    }
+  }
+  /**
+   * @name Preview speech
+   * @description Speaks the caller's words in one voice, so a break can be heard before it is written for air
+   */
+  async previewSpeech(body) {
+    const result = await this.fetch(`/voices/preview`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return {
+      contentType: readContentType(result),
+      data: await result.blob()
+    };
+  }
+  /**
+   * @name Delete segment
+   * @description Removes a recording and the inbox file behind it, so the next scan does not read it back in
+   */
+  async deleteSegment(id) {
+    const result = await this.fetch(`/segments/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Get segment audio
+   * @description The audio of one segment
+   */
+  async getSegmentAudio(id) {
+    const result = await this.fetch(`/segments/${encodeURIComponent(id)}/audio`, {
+      method: "GET",
+      expectStatuses: [
+        304
+      ]
+    });
+    switch (result.status) {
+      case 304:
+        return {
+          status: 304
+        };
+      default:
+        return {
+          status: 200,
+          contentType: readContentType(result),
+          data: await result.blob(),
+          headers: {
+            cacheControl: result.headers.get("cache-control") ?? void 0,
+            etag: result.headers.get("etag") ?? void 0
+          }
+        };
+    }
+  }
+  /**
+   * @name Get stored audio
+   * @description Audio out of the segment store, addressed by content rather than by row
+   */
+  async getStoredAudio(checksum, ext) {
+    const result = await this.fetch(`/audio/${encodeURIComponent(checksum)}/${encodeURIComponent(ext)}`, {
+      method: "GET",
+      expectStatuses: [
+        304
+      ]
+    });
+    switch (result.status) {
+      case 304:
+        return {
+          status: 304
+        };
+      default:
+        return {
+          status: 200,
+          contentType: readContentType(result),
+          data: await result.blob(),
+          headers: {
+            cacheControl: result.headers.get("cache-control") ?? void 0,
+            etag: result.headers.get("etag") ?? void 0
+          }
+        };
+    }
+  }
+  /**
+   * @name List pronunciations
+   * @description The station's lexicon: what it says, what has been proposed to it, and what it has turned down
+   */
+  async listPronunciations(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/pronunciations${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Create pronunciation
+   * @description Adds one the operator typed. It is said from the next render on
+   */
+  async createPronunciation(body) {
+    const result = await this.fetch(`/pronunciations`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Update pronunciation
+   * @description Rewrites one entry's words, whoever proposed it
+   */
+  async updatePronunciation(id, body) {
+    const result = await this.fetch(`/pronunciations/${encodeURIComponent(id)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Delete pronunciation
+   * @description Removes an entry outright. Turning a PROPOSAL down is a state rather than a deletion, because a deleted one comes back on the next pass
+   */
+  async deletePronunciation(id) {
+    const result = await this.fetch(`/pronunciations/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Set pronunciation state
+   * @description Accepts a proposal, turns one down, or takes an entry out of use without losing what it said
+   */
+  async setPronunciationState(id, body) {
+    const result = await this.fetch(`/pronunciations/${encodeURIComponent(id)}/state`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name List pads
+   * @description Every sound the station holds, board by board
+   */
+  async listPads() {
+    const result = await this.fetch(`/pads`, {
+      method: "GET"
+    });
+    return revivePadList(await parseJson(result));
+  }
+  /**
+   * @name Upload pad
+   * @description Takes a sound in from the browser and puts it on a board. The file lands in the pad library on disk, so it survives a rebuild and an archive carries it
+   */
+  async uploadPad(body) {
+    const result = await this.fetch(`/pads`, {
+      method: "POST",
+      body
+    });
+    return revivePadList(await parseJson(result));
+  }
+  /**
+   * @name Scan the pad library
+   * @description Takes whatever audio is sitting in the pad library directory onto its board. Safe to repeat: a file nobody has touched is seen and left alone
+   */
+  async scanThePadLibrary() {
+    const result = await this.fetch(`/pads/scan`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Fetch pad
+   * @description Fetches a sound from an address and puts it on a board. The operator names the address, so this is them choosing a file exactly as dropping one in the library is
+   */
+  async fetchPad(body) {
+    const result = await this.fetch(`/pads/fetch`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return revivePadList(await parseJson(result));
+  }
+  /**
+   * @name Delete pad
+   * @description Removes a sound the console put there, and the file it wrote for it
+   */
+  async deletePad(id) {
+    const result = await this.fetch(`/pads/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return revivePadList(await parseJson(result));
+  }
+  /**
+   * @name Set pad state
+   * @description Turns a sound down, or puts one back. Answers the whole rack, since one pad changing state is one row moving between two sections of the same page
+   */
+  async setPadState(id, body) {
+    const result = await this.fetch(`/pads/${encodeURIComponent(id)}/state`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return revivePadList(await parseJson(result));
+  }
+  /**
+   * @name Get pad audio
+   * @description The sound itself, so an operator can hear what they dropped in
+   */
+  async getPadAudio(id) {
+    const result = await this.fetch(`/pads/${encodeURIComponent(id)}/audio`, {
+      method: "GET",
+      expectStatuses: [
+        304
+      ]
+    });
+    switch (result.status) {
+      case 304:
+        return {
+          status: 304
+        };
+      default:
+        return {
+          status: 200,
+          contentType: readContentType(result),
+          data: await result.blob(),
+          headers: {
+            cacheControl: result.headers.get("cache-control") ?? void 0,
+            etag: result.headers.get("etag") ?? void 0
+          }
+        };
+    }
+  }
+  /**
+   * @name Create pad set
+   * @description Names a new set, or answers the one already under that key
+   */
+  async createPadSet(body) {
+    const result = await this.fetch(`/pads/sets`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return revivePadList(await parseJson(result));
+  }
+  /**
+   * @name Update pad set
+   * @description Renames a set. The KEY moves with it, so every persona naming the old one stops finding it
+   */
+  async updatePadSet(id, body) {
+    const result = await this.fetch(`/pads/sets/${encodeURIComponent(id)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return revivePadList(await parseJson(result));
+  }
+  /**
+   * @name Delete pad set
+   * @description Removes a set and its memberships, and no pads at all
+   */
+  async deletePadSet(id) {
+    const result = await this.fetch(`/pads/sets/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return revivePadList(await parseJson(result));
+  }
+  /**
+   * @name Set pad membership
+   * @description Puts a pad on a set or takes it off. Refused where the set already answers to that name, because a script writes a name
+   */
+  async setPadMembership(id, body) {
+    const result = await this.fetch(`/pads/sets/${encodeURIComponent(id)}/pads`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return revivePadList(await parseJson(result));
+  }
+};
+
+// src/schedule/schedule.client.ts
+var ScheduleClient = class {
+  static {
+    __name(this, "ScheduleClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List schedule
+   * @description Every slot in this station's schedule, earliest in the day first
+   */
+  async listSchedule() {
+    const result = await this.fetch(`/schedule`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Create schedule slot
+   * @description Adds a slot. The station does not change over until its start time comes round
+   */
+  async createScheduleSlot(body) {
+    const result = await this.fetch(`/schedule`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Read current slot
+   * @description Which slot the clock says should be on, and which one the station is actually airing
+   */
+  async readCurrentSlot() {
+    const result = await this.fetch(`/schedule/current`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Read timetable
+   * @description The station's day as blocks, contiguous and gapless, for drawing
+   */
+  async readTimetable(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/schedule/timetable${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Update schedule slot
+   * @description Rewrites a slot. Takes effect at its next boundary rather than immediately
+   */
+  async updateScheduleSlot(id, body) {
+    const result = await this.fetch(`/schedule/${encodeURIComponent(id)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Delete schedule slot
+   * @description Removes a slot. Whatever is on air stays on until the next slot begins
+   */
+  async deleteScheduleSlot(id) {
+    const result = await this.fetch(`/schedule/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/settings/settings.client.ts
+var SettingsClient = class {
+  static {
+    __name(this, "SettingsClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name Get settings
+   * @description Every station setting, its descriptor and its current value
+   */
+  async getSettings() {
+    const result = await this.fetch(`/settings`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Update settings
+   * @description Applies a submitted settings form and answers with the settings as they now stand
+   */
+  async updateSettings(body) {
+    const result = await this.fetch(`/settings`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/station/types/logs.types.ts
+import { Decimal as Decimal9 } from "decimal.js";
+import { DateTime as DateTime9 } from "luxon";
+Decimal9.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt9 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime9.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function reviveLogSource(raw) {
+  const __o0 = raw;
+  if (__o0["lastWriteAt"] != null) {
+    __o0["lastWriteAt"] = __dt9(__o0["lastWriteAt"], "LogSource.lastWriteAt");
+  }
+  return raw;
+}
+__name(reviveLogSource, "reviveLogSource");
+function reviveLogSourceList(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["sources"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveLogSource(__a1[__i2]);
+    }
+  }
+  return raw;
+}
+__name(reviveLogSourceList, "reviveLogSourceList");
+
+// src/station/types/station.types.ts
+import { Decimal as Decimal10 } from "decimal.js";
+import { DateTime as DateTime10 } from "luxon";
+Decimal10.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt10 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime10.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function reviveStationHeartbeat(raw) {
+  const __o0 = raw;
+  __o0["startedAt"] = __dt10(__o0["startedAt"], "StationHeartbeat.startedAt");
+  if (__o0["lastBeat"] != null) {
+    __o0["lastBeat"] = __dt10(__o0["lastBeat"], "StationHeartbeat.lastBeat");
+  }
+  return raw;
+}
+__name(reviveStationHeartbeat, "reviveStationHeartbeat");
+function reviveStationCheckup(raw) {
+  const __o0 = raw;
+  __o0["readAt"] = __dt10(__o0["readAt"], "StationCheckup.readAt");
+  if (__o0["heartbeats"] != null) {
+    {
+      const __a1 = __o0["heartbeats"];
+      for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+        reviveStationHeartbeat(__a1[__i2]);
+      }
+    }
+  }
+  return raw;
+}
+__name(reviveStationCheckup, "reviveStationCheckup");
+
+// src/station/types/traces.types.ts
+import { Decimal as Decimal11 } from "decimal.js";
+import { DateTime as DateTime11 } from "luxon";
+Decimal11.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt11 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime11.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function reviveTraceDecision(raw) {
+  const __o0 = raw;
+  __o0["at"] = __dt11(__o0["at"], "TraceDecision.at");
+  return raw;
+}
+__name(reviveTraceDecision, "reviveTraceDecision");
+function reviveTraceSpan(raw) {
+  const __o0 = raw;
+  __o0["at"] = __dt11(__o0["at"], "TraceSpan.at");
+  return raw;
+}
+__name(reviveTraceSpan, "reviveTraceSpan");
+function reviveTracesPage(raw) {
+  const __o0 = raw;
+  {
+    const __a1 = __o0["decisions"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveTraceDecision(__a1[__i2]);
+    }
+  }
+  return raw;
+}
+__name(reviveTracesPage, "reviveTracesPage");
+function reviveTraceDetail(raw) {
+  const __o0 = raw;
+  reviveTraceDecision(__o0["decision"]);
+  {
+    const __a1 = __o0["spans"];
+    for (let __i2 = 0; __i2 < __a1.length; __i2++) {
+      reviveTraceSpan(__a1[__i2]);
+    }
+  }
+  if (__o0["parent"] != null) {
+    reviveTraceDecision(__o0["parent"]);
+  }
+  {
+    const __a3 = __o0["caused"];
+    for (let __i4 = 0; __i4 < __a3.length; __i4++) {
+      reviveTraceDecision(__a3[__i4]);
+    }
+  }
+  return raw;
+}
+__name(reviveTraceDetail, "reviveTraceDetail");
+
+// src/station/station.client.ts
+var StationClient = class {
+  static {
+    __name(this, "StationClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List logs
+   * @description Every log this install has, present or not, with its size and when it was last written
+   */
+  async listLogs() {
+    const result = await this.fetch(`/logs`, {
+      method: "GET"
+    });
+    return reviveLogSourceList(await parseJson(result));
+  }
+  /**
+   * @name Read log
+   * @description A tail of one log, newest first
+   */
+  async readLog(id, query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/logs/${encodeURIComponent(id)}${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Download log
+   * @description The retained log as a plain-text attachment, oldest first, as the file is written
+   */
+  async downloadLog(id) {
+    const result = await this.fetch(`/logs/${encodeURIComponent(id)}/download`, {
+      method: "GET"
+    });
+    const data = await result.text();
+    return {
+      data,
+      headers: {
+        contentDisposition: result.headers.get("Content-Disposition") ?? void 0
+      }
+    };
+  }
+  /**
+   * @name Read station attention
+   * @description Everything wrong or waiting, worst first, each with the console page that can act on it
+   */
+  async readStationAttention() {
+    const result = await this.fetch(`/station/attention`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Read station checkup
+   * @description The loops the station runs and how much of the library it has looked at
+   */
+  async readStationCheckup() {
+    const result = await this.fetch(`/station/checkup`, {
+      method: "GET"
+    });
+    return reviveStationCheckup(await parseJson(result));
+  }
+  /**
+   * @name Read traces
+   * @description Recent decisions, newest first, folded to one row each
+   */
+  async readTraces(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/traces${qs}`, {
+      method: "GET"
+    });
+    return reviveTracesPage(await parseJson(result));
+  }
+  /**
+   * @name Read trace
+   * @description One decision: every call it made, and the decisions on either side of it
+   */
+  async readTrace(id) {
+    const result = await this.fetch(`/traces/${encodeURIComponent(id)}`, {
+      method: "GET"
+    });
+    return reviveTraceDetail(await parseJson(result));
+  }
+};
+
+// src/storage/types/storage.types.ts
+import { Decimal as Decimal12 } from "decimal.js";
+import { DateTime as DateTime12 } from "luxon";
+Decimal12.set({
+  toExpNeg: -9e15,
+  toExpPos: 9e15
+});
+var __dt12 = /* @__PURE__ */ __name((v, path) => {
+  if (typeof v !== "string") {
+    throw new TypeError(`ContractKit: expected an ISO 8601 string at '${path}', received ${typeof v}.`);
+  }
+  const d = DateTime12.fromISO(v);
+  if (!d.isValid) throw new TypeError(`ContractKit: '${v}' at '${path}' is not a valid ISO 8601 datetime.`);
+  return d;
+}, "__dt");
+function reviveStorageReport(raw) {
+  const __o0 = raw;
+  __o0["readAt"] = __dt12(__o0["readAt"], "StorageReport.readAt");
+  return raw;
+}
+__name(reviveStorageReport, "reviveStorageReport");
+
+// src/storage/storage.client.ts
+var StorageClient = class {
+  static {
+    __name(this, "StorageClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name Read storage
+   * @description What is on disk, per store, against what the database says should be
+   */
+  async readStorage() {
+    const result = await this.fetch(`/storage`, {
+      method: "GET"
+    });
+    return reviveStorageReport(await parseJson(result));
+  }
+};
+
+// src/stream/stream.client.ts
+var StreamClient = class {
+  static {
+    __name(this, "StreamClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name Get HLS playlist
+   * @description One HLS playlist, and the tick that says somebody is still listening to it
+   */
+  async getHLSPlaylist(name) {
+    const result = await this.fetch(`/hls/${encodeURIComponent(name)}`, {
+      method: "GET"
+    });
+    const data = await result.blob();
+    return {
+      data,
+      headers: {
+        cacheControl: result.headers.get("cache-control") ?? void 0
+      }
+    };
+  }
+  /**
+   * @name Read fetcher authorization
+   * @description What the track fetcher holds by way of a Spotify login, and whether an authorization is already waiting to be finished
+   */
+  async readFetcherAuthorization() {
+    const result = await this.fetch(`/stream/authorization`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Start fetcher authorization
+   * @description Starts the fetcher's one-time authorization and answers with the URL to open. Starting another replaces whichever was pending
+   */
+  async startFetcherAuthorization() {
+    const result = await this.fetch(`/stream/authorization`, {
+      method: "POST"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Finish fetcher authorization
+   * @description Finishes an authorization from the address the operator's browser ended up at
+   */
+  async finishFetcherAuthorization(body) {
+    const result = await this.fetch(`/stream/authorization/complete`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/topics/topics.client.ts
+var TopicsClient = class {
+  static {
+    __name(this, "TopicsClient");
+  }
+  fetch;
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * @name List topics
+   * @description Every subject this station has named, for one sort of break or for all of them
+   */
+  async listTopics(query) {
+    const qs = buildQueryString(query);
+    const result = await this.fetch(`/topics${qs}`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Create topic
+   * @description Names a new subject. Nothing uses it until something points at it
+   */
+  async createTopic(body) {
+    const result = await this.fetch(`/topics`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name List topic kinds
+   * @description Which sorts of break have subjects, and the form each one's settings are edited with
+   */
+  async listTopicKinds() {
+    const result = await this.fetch(`/topics/kinds`, {
+      method: "GET"
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Update topic
+   * @description Rewrites one subject. A break already written keeps the words it was given
+   */
+  async updateTopic(id, body) {
+    const result = await this.fetch(`/topics/${encodeURIComponent(id)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body, bigIntReplacer)
+    });
+    return await parseJson(result);
+  }
+  /**
+   * @name Delete topic
+   * @description Removes a subject, and any band on the format clock that asked for it
+   */
+  async deleteTopic(id) {
+    const result = await this.fetch(`/topics/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+    return await parseJson(result);
+  }
+};
+
+// src/deadair.sdk.ts
+var DeadairSdk = class {
+  static {
+    __name(this, "DeadairSdk");
+  }
+  activity;
+  art;
+  authentication;
+  catalog;
+  charts;
+  director;
+  history;
+  news;
+  nowplaying;
+  onboarding;
+  personas;
+  playlists;
+  playout;
+  plugins;
+  productions;
+  render;
+  schedule;
+  settings;
+  station;
+  storage;
+  stream;
+  topics;
+  constructor(options) {
+    const sdkFetch = options.fetch ?? createSdkFetch(options);
+    this.activity = new ActivityClient(sdkFetch);
+    this.art = new ArtClient(sdkFetch);
+    this.authentication = new AuthenticationClient(sdkFetch);
+    this.catalog = new CatalogClient(sdkFetch);
+    this.charts = new ChartsClient(sdkFetch);
+    this.director = new DirectorClient(sdkFetch);
+    this.history = new HistoryClient(sdkFetch);
+    this.news = new NewsClient(sdkFetch);
+    this.nowplaying = new NowplayingClient(sdkFetch);
+    this.onboarding = new OnboardingClient(sdkFetch);
+    this.personas = new PersonasClient(sdkFetch);
+    this.playlists = new PlaylistsClient(sdkFetch);
+    this.playout = new PlayoutClient(sdkFetch);
+    this.plugins = new PluginsClient(sdkFetch);
+    this.productions = new ProductionsClient(sdkFetch);
+    this.render = new RenderClient(sdkFetch);
+    this.schedule = new ScheduleClient(sdkFetch);
+    this.settings = new SettingsClient(sdkFetch);
+    this.station = new StationClient(sdkFetch);
+    this.storage = new StorageClient(sdkFetch);
+    this.stream = new StreamClient(sdkFetch);
+    this.topics = new TopicsClient(sdkFetch);
+  }
+};
+export {
+  ActivityClient,
+  ArtClient,
+  AuthenticationClient,
+  AuthenticationFactorsClient,
+  AuthenticationSessionsClient,
+  CatalogClient,
+  ChartsClient,
+  DeadairSdk,
+  DirectorClient,
+  HistoryClient,
+  NewsClient,
+  NowplayingClient,
+  OnboardingClient,
+  PersonasClient,
+  PlaylistsClient,
+  PlayoutClient,
+  PluginsClient,
+  ProductionsClient,
+  RenderClient,
+  ScheduleClient,
+  SdkError,
+  SettingsClient,
+  StationClient,
+  StorageClient,
+  StreamClient,
+  TopicsClient,
+  bigIntReplacer,
+  bigIntReviver,
+  buildHeaders,
+  buildQueryString,
+  createSdkFetch,
+  parseBigIntHeader,
+  parseJson,
+  parseJsonWithBigInt,
+  readContentType,
+  reviveActivityEntry,
+  reviveActivityPage,
+  reviveAlbumEnrichmentDetail,
+  reviveAlbumEnrichmentSource,
+  reviveArtistEnrichmentDetail,
+  reviveArtistEnrichmentSource,
+  reviveAuthenticationFactorRegistrationResponse,
+  reviveAuthenticationLoginStartResponse,
+  reviveAuthenticationRegistration,
+  reviveAuthenticationTokenResponse,
+  reviveAuthenticationTokenResponseOutput,
+  reviveAuthenticatorFactorRegistrationResponse,
+  reviveBaseAuthenticationLoginStartResponse,
+  reviveCodeAuthenticationLoginStartResponse,
+  reviveEmailFactorRegistrationResponse,
+  reviveFactClaim,
+  reviveFactorChallengeEmailStartResponse,
+  reviveFactorChallengeEmailStartResponseOutput,
+  reviveFactorChallengeFidoStartResponse,
+  reviveFactorChallengeFidoStartResponseOutput,
+  reviveFactorChallengePhoneStartResponse,
+  reviveFactorChallengePhoneStartResponseOutput,
+  reviveFactorChallengeStartResponse,
+  reviveFactorChallengeStartResponseOutput,
+  reviveFidoAuthenticationLoginStartResponse,
+  reviveFidoFactorRegistrationResponse,
+  reviveHistoryEntry,
+  reviveHistoryPage,
+  reviveLinkAuthenticationLoginStartResponse,
+  reviveLogSource,
+  reviveLogSourceList,
+  reviveLogin,
+  reviveMfaEnrollFidoStartResponse,
+  reviveMfaEnrollPhoneStartResponse,
+  reviveMfaRequiredResponse,
+  reviveMfaRequiredResponseOutput,
+  reviveOidcAuthenticationLoginStartResponse,
+  reviveOidcLoginStartResponse,
+  revivePad,
+  revivePadList,
+  revivePhoneFactorRegistrationResponse,
+  revivePluginDetail,
+  revivePluginImportResult,
+  revivePluginSummary,
+  reviveProduction,
+  reviveProductionList,
+  reviveProductionRequest,
+  reviveScriptAttempt,
+  reviveScriptHistoryPage,
+  reviveSession,
+  reviveSessionFactor,
+  reviveStationCheckup,
+  reviveStationHeartbeat,
+  reviveStepUpStartResponse,
+  reviveStepUpStartResponseOutput,
+  reviveStorageReport,
+  reviveTraceDecision,
+  reviveTraceDetail,
+  reviveTraceSpan,
+  reviveTracesPage,
+  reviveTrackAnalysis,
+  reviveTrackBinding,
+  reviveTrackDetail,
+  reviveTrackEnrichmentDetail,
+  reviveTrackEnrichmentSource,
+  reviveTrackPlay
+};
+//# sourceMappingURL=index.js.map