@delegance/sdk 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 // src/types/index.ts
 import { z } from "zod";
-var CompanySizeSchema = z.enum(["1", "2-10", "11-25", "26-50", "51-100", "100-499", "500+"]);
+var CompanySizeSchema = z.enum(["0", "1", "2-10", "11-25", "26-50", "51-100", "100-499", "500+"]);
 var CreateCompanySchema = z.object({
   name: z.string().min(1).max(255),
   legalName: z.string().max(255).optional(),
@@ -22,7 +22,7 @@ var CreateCompanySchema = z.object({
     zip: z.string().regex(/^\d{5}(-\d{4})?$/)
   }).optional(),
   externalId: z.string().max(255).optional(),
-  metadata: z.record(z.unknown()).optional()
+  metadata: z.record(z.string(), z.unknown()).optional()
 });
 var DocumentTypeSchema = z.enum([
   "policy",
@@ -77,13 +77,29 @@ var RateLimitError = class extends DeleganceError {
     this.name = "RateLimitError";
   }
 };
+var ForbiddenError = class extends DeleganceError {
+  constructor(message, traceId) {
+    super(message, 403, traceId);
+    this.name = "ForbiddenError";
+  }
+};
+var NotImplementedError = class extends DeleganceError {
+  constructor(message, traceId) {
+    super(message, 501, traceId);
+    this.name = "NotImplementedError";
+  }
+};
 
 // src/utils/http.ts
-var SDK_VERSION = "0.1.0";
+var SDK_VERSION = "0.2.0";
+var DEFAULT_BASE_URL = "https://portal.delegancebrokerage.com";
+function isRetryableStatus(status) {
+  return status >= 500 && status !== 501;
+}
 var HttpClient = class {
   constructor(config) {
     this.config = {
-      baseUrl: (config.baseUrl || "https://app.delegance.ai").replace(/\/$/, ""),
+      baseUrl: (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, ""),
       apiKey: config.apiKey,
       timeout: config.timeout || 3e4,
       retries: config.retries ?? 3,
@@ -94,7 +110,8 @@ var HttpClient = class {
     const { method, path, body, headers = {}, timeout, isFormData } = options;
     const url = `${this.config.baseUrl}${path}`;
     const requestHeaders = {
-      "Authorization": `Bearer ${this.config.apiKey}`,
+      // No key = an unauthenticated call (signup, the key exchange).
+      ...this.config.apiKey ? { "Authorization": `Bearer ${this.config.apiKey}` } : {},
       "User-Agent": `delegance-sdk/${SDK_VERSION}`,
       ...this.config.headers,
       ...headers
@@ -157,6 +174,7 @@ var HttpClient = class {
    */
   async executeWithRetry(buildRequest, timeoutMs) {
     let lastError = null;
+    let lastInformative = null;
     let attempts = 0;
     while (attempts <= this.config.retries) {
       const controller = new AbortController();
@@ -165,21 +183,34 @@ var HttpClient = class {
         const { url, init } = buildRequest();
         const response = await fetch(url, { ...init, signal: controller.signal });
         const data = await response.json().catch(() => ({}));
-        const traceId = data.traceId;
+        const { traceId } = data;
         if (!response.ok) {
-          throw this.handleErrorResponse(response.status, data, traceId);
+          const err = this.handleErrorResponse(response.status, data, traceId);
+          if (typeof data.reason === "string") err.reason = data.reason;
+          if (data && typeof data === "object") err.body = data;
+          if (err instanceof RateLimitError && err.retryAfter === void 0) {
+            const header = Number(response.headers?.get?.("Retry-After"));
+            if (Number.isFinite(header) && header > 0) err.retryAfter = header;
+          }
+          throw err;
         }
         return data;
       } catch (error) {
         lastError = error;
-        if (error instanceof AuthenticationError || error instanceof ValidationError || error instanceof NotFoundError || error instanceof RateLimitError) {
+        if (error instanceof DeleganceError && error.message && error.message !== "Unknown error") {
+          lastInformative = error;
+        }
+        if (error instanceof DeleganceError && (!isRetryableStatus(error.statusCode) || error.reason === "not_available")) {
           throw error;
         }
         if (attempts < this.config.retries) {
           attempts++;
-          await this.delay(Math.pow(2, attempts) * 1e3);
+          await this.delay(2 ** attempts * 1e3);
           continue;
         }
+        if (error instanceof DeleganceError && error.message === "Unknown error" && lastInformative) {
+          throw lastInformative;
+        }
         throw error;
       } finally {
         clearTimeout(timeoutId);
@@ -189,12 +220,14 @@ var HttpClient = class {
   }
   handleErrorResponse(status, data, traceId) {
     const message = data.message || data.error || "Unknown error";
-    const details = data.details;
+    const { details } = data;
     switch (status) {
       case 401:
         return new AuthenticationError(message, traceId);
       case 400:
         return new ValidationError(message, details, traceId);
+      case 403:
+        return new ForbiddenError(message, traceId);
       case 404:
         return new NotFoundError(message, traceId);
       case 429:
@@ -203,6 +236,8 @@ var HttpClient = class {
           data.retryAfter,
           traceId
         );
+      case 501:
+        return new NotImplementedError(message, traceId);
       default:
         return new DeleganceError(message, status, traceId, details);
     }
@@ -804,6 +839,7 @@ var QuotesModule = class {
 };
 
 // src/modules/policies.ts
+import { randomUUID } from "crypto";
 var PoliciesModule = class {
   constructor(http) {
     this.http = http;
@@ -868,6 +904,40 @@ var PoliciesModule = class {
       throw error;
     }
   }
+  /**
+   * Ask to cancel a policy. The request waits for the insured's signature,
+   * collected at `signatureUrl` by an owner or admin; a broker reviews the
+   * claims-made continuity check before anything reaches the carrier.
+   */
+  async requestCancellation(policyId, input, opts = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/v1/policies/${encodeURIComponent(policyId)}/cancellation`,
+      body: input,
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID() }
+    });
+  }
+  /**
+   * Sign a cancellation request as an owner or admin. Signing needs a step-up
+   * code: call once without `code` to email it (202 with `stepUpId`), then
+   * again with `stepUpId` and `code`.
+   */
+  async signCancellation(requestId, input, opts = {}) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/v1/policy-cancellations/${encodeURIComponent(requestId)}/sign`,
+      body: input,
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID() }
+    });
+  }
+  /** One cancellation request's status. */
+  async getCancellation(requestId) {
+    const res = await this.http.request({
+      method: "GET",
+      path: `/api/v1/policy-cancellations/${encodeURIComponent(requestId)}`
+    });
+    return res.request;
+  }
 };
 
 // src/modules/coi.ts
@@ -1023,6 +1093,7 @@ var SOVModule = class {
 };
 
 // src/modules/api-keys.ts
+var API_KEY_SCOPES = ["read", "write", "admin", "appetite:read", "mcp:read", "mcp:orin"];
 var ApiKeysModule = class {
   constructor(http) {
     this.http = http;
@@ -1135,8 +1206,18 @@ var ApiKeysModule = class {
     if (idempotency?.idempotencyKey) {
       requestOptions.headers = { "Idempotency-Key": idempotency.idempotencyKey };
     }
-    const response = await this.http.request(requestOptions);
-    return response.data;
+    try {
+      const response = await this.http.request(requestOptions);
+      return response.data;
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        throw new NotImplementedError(
+          "Server-side key rotation is not available yet. Create a replacement key with apiKeys.create() using the same scopes, then revoke the old key in the portal.",
+          error.traceId
+        );
+      }
+      throw error;
+    }
   }
 };
 
@@ -1326,6 +1407,519 @@ var OnboardingModule = class {
     });
     return response.data;
   }
+  /** Poll the canonical onboarding state machine. Callable pre-verification. */
+  async state() {
+    const response = await this.http.request({
+      method: "GET",
+      path: "/api/v1/onboarding/state"
+    });
+    return response.data;
+  }
+  /**
+   * Issue (or re-issue) the human verification challenge. Delegance emails a
+   * confirmation link to the company contact email. Hand that link to a human;
+   * the agent cannot self-verify.
+   */
+  async requestVerification() {
+    const response = await this.http.request({
+      method: "POST",
+      path: "/api/v1/onboarding/verification"
+    });
+    return { state: response.data.state, sentTo: response.data.sentTo };
+  }
+  /** Poll state() until `target` is reached or `timeoutMs` elapses. */
+  async waitForState(target, options = {}) {
+    const intervalMs = options.intervalMs ?? 5e3;
+    const timeoutMs = options.timeoutMs ?? 10 * 60 * 1e3;
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0 || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      throw new ValidationError("intervalMs and timeoutMs must be positive numbers");
+    }
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const current = await this.state();
+      if (current.state === target) return current;
+      if (Date.now() + intervalMs > deadline) {
+        throw new Error(
+          `waitForState('${target}') timed out after ${timeoutMs}ms (last state: ${current.state})`
+        );
+      }
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+  }
+};
+
+// src/modules/appetite.ts
+function withoutEnvelope(response) {
+  const copy = { ...response };
+  delete copy.success;
+  return copy;
+}
+var AppetiteModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Start an appetite match. Returns the result directly on a warm cache hit,
+   * or a queued job to poll with `getMatch()`.
+   *
+   * @example
+   * ```typescript
+   * const start = await client.appetite.match({ state: 'CA', industry: 'restaurant' });
+   * const result = start.status === 'succeeded'
+   *   ? start
+   *   : await client.appetite.waitForMatch(start.jobId);
+   * ```
+   */
+  async match(input) {
+    if (!input.state || input.state.trim().length !== 2) {
+      throw new ValidationError("state must be a two-letter code");
+    }
+    if (!input.industry && !input.businessDescription && !input.naicsCode && !input.sicCode) {
+      throw new ValidationError("One of industry, businessDescription, naicsCode, or sicCode is required");
+    }
+    const response = await this.http.request({
+      method: "POST",
+      path: "/api/v1/appetite/match",
+      body: input
+    });
+    if (typeof response.jobId === "string" && typeof response.statusUrl === "string") {
+      return {
+        status: "queued",
+        jobId: response.jobId,
+        statusUrl: response.statusUrl,
+        estimatedSeconds: response.estimatedSeconds ?? 20,
+        traceId: response.traceId
+      };
+    }
+    return {
+      ...withoutEnvelope(response),
+      status: "succeeded",
+      cached: true,
+      jobId: null,
+      traceId: response.traceId
+    };
+  }
+  /** Read a match job. Unknown, expired, and other-tenant ids all raise NotFoundError. */
+  async getMatch(jobId) {
+    const response = await this.http.request({
+      method: "GET",
+      path: `/api/v1/appetite/match/${encodeURIComponent(jobId)}`
+    });
+    return withoutEnvelope(response);
+  }
+  /**
+   * Poll a job until it succeeds. Throws on a failed job (with the sanitized
+   * errorCode) or on timeout.
+   */
+  async waitForMatch(jobId, options = {}) {
+    const intervalMs = options.intervalMs ?? 3e3;
+    const timeoutMs = options.timeoutMs ?? 2 * 60 * 1e3;
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0 || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      throw new ValidationError("intervalMs and timeoutMs must be positive numbers");
+    }
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const job = await this.getMatch(jobId);
+      if (job.status === "succeeded") return job;
+      if (job.status === "failed") {
+        throw new DeleganceError(
+          `Appetite match failed: ${job.errorCode}${job.retryable ? " (retryable)" : ""}`,
+          500,
+          job.traceId
+        );
+      }
+      if (Date.now() + intervalMs > deadline) {
+        throw new DeleganceError(`Appetite match ${jobId} still ${job.status} after ${timeoutMs}ms`, 408);
+      }
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+  }
+};
+
+// src/modules/leads.ts
+var LeadsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a lead.
+   *
+   * @example
+   * ```typescript
+   * const { companyId } = await client.leads.create({
+   *   name: 'Riverbend Bakery',
+   *   contactEmail: 'owner@riverbend.example',
+   *   state: 'TX',
+   *   externalId: 'crm-4411',
+   * });
+   * ```
+   */
+  async create(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/api/v1/leads",
+      body: input
+    });
+  }
+};
+
+// src/modules/instant-quotes.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var InstantQuotesModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * `fresh: true` always mints a new submission instead of reusing a warm
+   * session for the same coverages. Use it with `submit({ replace: true })`
+   * to re-quote coverage that already has a request with carriers.
+   */
+  async start(coverages, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: "/api/v1/quotes/instant/session",
+      body: opts.fresh ? { coverages, fresh: true } : { coverages }
+    });
+    return res.data;
+  }
+  async submit(input, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: "/api/v1/quotes/instant/submit",
+      body: input,
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID2() }
+    });
+    return res.data;
+  }
+  async status(submissionId) {
+    const res = await this.http.request({
+      method: "GET",
+      path: `/api/v1/quotes/instant/${encodeURIComponent(submissionId)}`
+    });
+    return res.data;
+  }
+  /** Polls `status` until every visible carrier resolved, or the timeout. */
+  async waitForQuotes(submissionId, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1e3;
+    const intervalMs = opts.intervalMs ?? 1e4;
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const s = await this.status(submissionId);
+      opts.onPoll?.(s);
+      const remaining = deadline - Date.now();
+      if (s.allCarriersResolved || remaining <= 0) return s;
+      await new Promise((resolve) => setTimeout(resolve, Math.min(intervalMs, remaining)));
+    }
+  }
+  /**
+   * After a `no_carriers` submit: the ACORD questions a broker needs to place
+   * the risk with a non-instant market. Pass the answers you submitted so
+   * facts you already gave are not asked again.
+   */
+  async brokerHandoffQuestions(submissionId, instantAnswers = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: `/api/v1/quotes/instant/${encodeURIComponent(submissionId)}/broker-handoff/questions`,
+      body: { instantAnswers }
+    });
+    return res.data;
+  }
+  /**
+   * Hands a `no_carriers` submission to a Delegance broker as a non-instant
+   * request, with whatever ACORD answers you have. `complete: false` says you
+   * stopped early; the broker asks the rest. A repeat call returns the same
+   * broker task.
+   */
+  async brokerHandoff(submissionId, input, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: `/api/v1/quotes/instant/${encodeURIComponent(submissionId)}/broker-handoff`,
+      body: input,
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID2() }
+    });
+    return res.data;
+  }
+  /** Requests a bind on one offer. A licensed broker reviews it; nothing is charged. */
+  async bind(submissionId, opportunityId, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: `/api/v1/quotes/instant/${encodeURIComponent(submissionId)}/bind`,
+      body: { opportunityId },
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID2() }
+    });
+    return res.data;
+  }
+  /**
+   * Bind through fast bind: an owner or admin attests the answers, gets a
+   * 6-digit code by email (the first call returns `stepUpRequired`), then calls
+   * again with `stepUpId` and `code`. A tier A offer returns `checkoutUrl`;
+   * any other offer goes to a broker.
+   */
+  async bindWithStepUp(submissionId, opportunityId, input = {}) {
+    const { idempotencyKey, ...rest } = input;
+    const res = await this.http.request({
+      method: "POST",
+      path: `/api/v1/quotes/instant/${encodeURIComponent(submissionId)}/bind`,
+      body: { opportunityId, ...rest },
+      headers: { "Idempotency-Key": idempotencyKey ?? randomUUID2() }
+    });
+    if (res.stepUpRequired && res.stepUpId) {
+      return { stepUpRequired: true, stepUpId: res.stepUpId, channel: "email", sentTo: res.sentTo ?? "", expiresAt: res.expiresAt ?? null };
+    }
+    return res.data;
+  }
+};
+
+// src/modules/payments.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var PaymentsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const res = await this.http.request({ method: "GET", path: "/api/v1/payments" });
+    return res.data.payments;
+  }
+  async checkout(paymentRequestId, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: `/api/v1/payments/${encodeURIComponent(paymentRequestId)}/checkout`,
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID3() }
+    });
+    return res.data;
+  }
+};
+
+// src/modules/bonds.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var BondsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async start(input) {
+    const res = await this.http.request({ method: "POST", path: "/api/v1/bonds/quote", body: input });
+    return res.data;
+  }
+  async answer(sessionId, answers, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: `/api/v1/bonds/quote/${encodeURIComponent(sessionId)}/answers`,
+      body: { answers },
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID4() }
+    });
+    return res.data;
+  }
+  async status(sessionId) {
+    const res = await this.http.request({
+      method: "GET",
+      path: `/api/v1/bonds/quote/${encodeURIComponent(sessionId)}`
+    });
+    return res.data;
+  }
+};
+
+// src/modules/claims.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var ClaimsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async file(input, opts = {}) {
+    const res = await this.http.request({
+      method: "POST",
+      path: "/api/v1/claims",
+      body: input,
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID5() }
+    });
+    return res.data;
+  }
+  async list(opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.status) q.set("status", opts.status);
+    if (opts.limit) q.set("limit", String(opts.limit));
+    const qs = q.toString();
+    const res = await this.http.request({ method: "GET", path: `/api/v1/claims${qs ? `?${qs}` : ""}` });
+    return res.data.claims;
+  }
+  async get(claimId) {
+    const res = await this.http.request({ method: "GET", path: `/api/v1/claims/${encodeURIComponent(claimId)}` });
+    return res.data;
+  }
+};
+
+// src/modules/feedback.ts
+import { randomUUID as randomUUID6 } from "crypto";
+var FEEDBACK_MESSAGE_MAX = 500;
+var FeedbackModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * File a report. Returns the reference id Delegance uses to find it.
+   *
+   * Each call sends one Idempotency-Key, and the client's automatic retries of
+   * that call reuse it, so a lost response never files the report twice. Pass
+   * your own key to make a retry of your own (a second call) safe as well.
+   */
+  async submit(input, opts = {}) {
+    const message = (input.message ?? "").trim();
+    if (!message) throw new Error("Feedback needs a message.");
+    if (message.length > FEEDBACK_MESSAGE_MAX) {
+      throw new Error(`Keep the message to ${FEEDBACK_MESSAGE_MAX} characters or fewer.`);
+    }
+    const body = { type: input.type ?? "bug", message };
+    if (input.context && Object.keys(input.context).length > 0) body.context = input.context;
+    const res = await this.http.request({
+      method: "POST",
+      path: "/api/v1/feedback",
+      body,
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID6() }
+    });
+    return { id: res.data.id };
+  }
+};
+
+// src/modules/signup.ts
+import { createHash, randomBytes, randomUUID as randomUUID7 } from "crypto";
+
+// src/utils/poll.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function pollUntilReady(poll, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 15 * 60 * 1e3;
+  const intervalMs = opts.intervalMs ?? 5e3;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    let wait = intervalMs;
+    try {
+      const r = await poll();
+      if (r.status !== "pending") return r;
+    } catch (err) {
+      if (!(err instanceof RateLimitError)) throw err;
+      wait = Math.max(intervalMs, (err.retryAfter ?? 60) * 1e3);
+    }
+    opts.onPoll?.();
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return { status: "pending" };
+    await sleep(Math.min(wait, remaining));
+  }
+}
+
+// src/modules/signup.ts
+function newDeviceSecret() {
+  const secret = randomBytes(32).toString("hex");
+  return { secret, hash: createHash("sha256").update(secret).digest("hex") };
+}
+var SignupModule = class {
+  constructor(makeHttp) {
+    this.makeHttp = makeHttp;
+  }
+  /** Creates the unverified company. Retries safely: sends an Idempotency-Key. */
+  async createAccount(input, opts = {}) {
+    const res = await this.makeHttp("").request({
+      method: "POST",
+      path: "/api/v1/companies",
+      body: input,
+      headers: { "Idempotency-Key": opts.idempotencyKey ?? randomUUID7() }
+    });
+    if (!res.bootstrapKey) {
+      throw new Error("The signup was already created by an earlier attempt; its key is shown only once. Start again with a new signup.");
+    }
+    return {
+      companyId: res.company.id,
+      bootstrapKey: res.bootstrapKey,
+      ...res.warnings?.length ? { warnings: res.warnings } : {}
+    };
+  }
+  async enroll(bootstrapKey, input) {
+    const res = await this.makeHttp(bootstrapKey).request({
+      method: "POST",
+      path: "/api/v1/onboarding/cli-enroll",
+      body: input
+    });
+    return res.data;
+  }
+  async requestVerification(bootstrapKey) {
+    const res = await this.makeHttp(bootstrapKey).request({
+      method: "POST",
+      path: "/api/v1/onboarding/verification",
+      body: {}
+    });
+    return { sentTo: res.data?.sentTo };
+  }
+  /**
+   * One poll. `pending` until the email link is clicked. Throws with
+   * `reason` = already_collected | account_exists (409) or expired (410).
+   */
+  async exchange(enrollmentId, deviceSecret) {
+    const res = await this.makeHttp("").request({
+      method: "POST",
+      path: "/api/v1/onboarding/cli-exchange",
+      body: { enrollmentId, deviceSecret }
+    });
+    if (res.data?.apiKey && res.data.keyPrefix && res.data.companyId) {
+      return { status: "ready", apiKey: res.data.apiKey, keyPrefix: res.data.keyPrefix, companyId: res.data.companyId };
+    }
+    if (res.data?.status === "pending") return { status: "pending" };
+    throw new Error('Unexpected response from the key exchange. Run "delegance verify" to retry.');
+  }
+  /**
+   * Polls `exchange` until the key is ready or `timeoutMs` passes. A 429 waits
+   * the server's Retry-After and keeps polling.
+   */
+  async waitForKey(enrollmentId, deviceSecret, opts = {}) {
+    return pollUntilReady(() => this.exchange(enrollmentId, deviceSecret), opts);
+  }
+};
+
+// src/modules/auth.ts
+var DeviceLoginModule = class {
+  constructor(makeHttp) {
+    this.makeHttp = makeHttp;
+  }
+  async start(input) {
+    const res = await this.makeHttp("").request({
+      method: "POST",
+      path: "/api/v1/auth/device",
+      body: input
+    });
+    return res.data;
+  }
+  /**
+   * One poll. `pending` until the portal user approves. Throws with `reason`
+   * = access_denied (403), already_collected (409), or expired (410).
+   */
+  async poll(loginId, deviceSecret) {
+    const res = await this.makeHttp("").request({
+      method: "POST",
+      path: "/api/v1/auth/device/token",
+      body: { loginId, deviceSecret }
+    });
+    const d = res.data ?? {};
+    if (d.apiKey && d.keyPrefix && d.companyId) {
+      return { status: "ready", apiKey: d.apiKey, keyPrefix: d.keyPrefix, companyId: d.companyId, scopes: d.scopes ?? [], expiresAt: d.expiresAt ?? null };
+    }
+    if (d.status === "pending") return { status: "pending" };
+    throw new Error('Unexpected response from the login poll. Run "delegance auth login" again.');
+  }
+  /** Polls until the key is ready or `timeoutMs` passes (then returns `pending`). */
+  async waitForKey(loginId, deviceSecret, opts = {}) {
+    return pollUntilReady(() => this.poll(loginId, deviceSecret), opts);
+  }
+};
+var AuthModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** The calling key: prefix, origin, scopes, company, and expiry. */
+  async keyInfo() {
+    const res = await this.http.request({ method: "GET", path: "/api/v1/auth/key" });
+    return res.data;
+  }
+  /** Extend a CLI key to 90 days from now. Throws `not_refreshable` (400) for portal keys. */
+  async refresh() {
+    const res = await this.http.request({ method: "POST", path: "/api/v1/auth/refresh", body: {} });
+    return res.data;
+  }
 };
 
 // src/client.ts
@@ -1358,6 +1952,14 @@ var DeleganceClient = class {
     this.usage = new UsageModule(this.http);
     this.knowledge = new KnowledgeModule(this.http);
     this.onboarding = new OnboardingModule(this.http);
+    this.appetite = new AppetiteModule(this.http);
+    this.leads = new LeadsModule(this.http);
+    this.instantQuotes = new InstantQuotesModule(this.http);
+    this.payments = new PaymentsModule(this.http);
+    this.bonds = new BondsModule(this.http);
+    this.claims = new ClaimsModule(this.http);
+    this.feedback = new FeedbackModule(this.http);
+    this.auth = new AuthModule(this.http);
   }
   /**
    * Get the SDK version
@@ -1398,28 +2000,52 @@ function createClientFromEnv() {
     baseUrl
   });
 }
+function createSignup(config = {}) {
+  return new SignupModule((apiKey) => new HttpClient({ apiKey, ...config }));
+}
+function createDeviceLogin(config = {}) {
+  return new DeviceLoginModule((apiKey) => new HttpClient({ apiKey, ...config }));
+}
 export {
+  API_KEY_SCOPES,
   ApiKeysModule,
+  AppetiteModule,
+  AuthModule,
   AuthenticationError,
+  BondsModule,
   COIModule,
   ChatModule,
+  ClaimsModule,
   CompaniesModule,
   CompanySizeSchema,
   CreateCompanySchema,
+  DEFAULT_BASE_URL,
   DeleganceClient,
   DeleganceError,
+  DeviceLoginModule,
   DocumentStatusSchema,
   DocumentTypeSchema,
   DocumentsModule,
+  FEEDBACK_MESSAGE_MAX,
+  FeedbackModule,
+  ForbiddenError,
+  InstantQuotesModule,
   KnowledgeModule,
+  LeadsModule,
   NotFoundError,
+  NotImplementedError,
   OnboardingModule,
+  PaymentsModule,
   PoliciesModule,
   QuotesModule,
   RateLimitError,
   SDK_VERSION,
   SOVModule,
+  SignupModule,
   UsageModule,
   ValidationError,
-  createClientFromEnv
+  createClientFromEnv,
+  createDeviceLogin,
+  createSignup,
+  newDeviceSecret
 };