@delegance/sdk 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -7,7 +7,7 @@ import { z } from 'zod';
 interface DeleganceClientConfig {
     /** API key for authentication (format: dlg_xxx_sk_xxx) */
     apiKey: string;
-    /** Base URL for the Delegance API (default: https://app.delegance.ai) */
+    /** Base URL for the Delegance API (default: https://portal.delegancebrokerage.com) */
     baseUrl?: string;
     /** Request timeout in milliseconds (default: 30000) */
     timeout?: number;
@@ -31,14 +31,32 @@ interface PaginatedResponse<T> extends APIResponse<T[]> {
         hasMore: boolean;
     };
 }
-declare const CompanySizeSchema: z.ZodEnum<["1", "2-10", "11-25", "26-50", "51-100", "100-499", "500+"]>;
+declare const CompanySizeSchema: z.ZodEnum<{
+    0: "0";
+    1: "1";
+    "2-10": "2-10";
+    "11-25": "11-25";
+    "26-50": "26-50";
+    "51-100": "51-100";
+    "100-499": "100-499";
+    "500+": "500+";
+}>;
 type CompanySize = z.infer<typeof CompanySizeSchema>;
 declare const CreateCompanySchema: z.ZodObject<{
     name: z.ZodString;
     legalName: z.ZodOptional<z.ZodString>;
     dba: z.ZodOptional<z.ZodString>;
     industry: z.ZodString;
-    companySize: z.ZodEnum<["1", "2-10", "11-25", "26-50", "51-100", "100-499", "500+"]>;
+    companySize: z.ZodEnum<{
+        0: "0";
+        1: "1";
+        "2-10": "2-10";
+        "11-25": "11-25";
+        "26-50": "26-50";
+        "51-100": "51-100";
+        "100-499": "100-499";
+        "500+": "500+";
+    }>;
     yearEstablished: z.ZodOptional<z.ZodString>;
     website: z.ZodOptional<z.ZodString>;
     fein: z.ZodOptional<z.ZodString>;
@@ -52,66 +70,10 @@ declare const CreateCompanySchema: z.ZodObject<{
         city: z.ZodString;
         state: z.ZodString;
         zip: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        street: string;
-        city: string;
-        state: string;
-        zip: string;
-        suite?: string | undefined;
-    }, {
-        street: string;
-        city: string;
-        state: string;
-        zip: string;
-        suite?: string | undefined;
-    }>>;
+    }, z.core.$strip>>;
     externalId: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    industry: string;
-    companySize: "1" | "2-10" | "11-25" | "26-50" | "51-100" | "100-499" | "500+";
-    contactEmail: string;
-    legalName?: string | undefined;
-    dba?: string | undefined;
-    yearEstablished?: string | undefined;
-    website?: string | undefined;
-    fein?: string | undefined;
-    companyStructure?: string | undefined;
-    description?: string | undefined;
-    contactPhone?: string | undefined;
-    address?: {
-        street: string;
-        city: string;
-        state: string;
-        zip: string;
-        suite?: string | undefined;
-    } | undefined;
-    externalId?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
-}, {
-    name: string;
-    industry: string;
-    companySize: "1" | "2-10" | "11-25" | "26-50" | "51-100" | "100-499" | "500+";
-    contactEmail: string;
-    legalName?: string | undefined;
-    dba?: string | undefined;
-    yearEstablished?: string | undefined;
-    website?: string | undefined;
-    fein?: string | undefined;
-    companyStructure?: string | undefined;
-    description?: string | undefined;
-    contactPhone?: string | undefined;
-    address?: {
-        street: string;
-        city: string;
-        state: string;
-        zip: string;
-        suite?: string | undefined;
-    } | undefined;
-    externalId?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
-}>;
+}, z.core.$strip>;
 type CreateCompanyInput = z.infer<typeof CreateCompanySchema>;
 interface Company {
     id: string;
@@ -123,9 +85,26 @@ interface Company {
     website?: string;
     createdAt: string;
 }
-declare const DocumentTypeSchema: z.ZodEnum<["policy", "loss_run", "financial_statement", "sov", "application", "certificate", "endorsement", "bor", "other"]>;
+declare const DocumentTypeSchema: z.ZodEnum<{
+    policy: "policy";
+    loss_run: "loss_run";
+    financial_statement: "financial_statement";
+    sov: "sov";
+    application: "application";
+    certificate: "certificate";
+    endorsement: "endorsement";
+    bor: "bor";
+    other: "other";
+}>;
 type DocumentType = z.infer<typeof DocumentTypeSchema>;
-declare const DocumentStatusSchema: z.ZodEnum<["pending", "processing", "completed", "processed", "error", "failed"]>;
+declare const DocumentStatusSchema: z.ZodEnum<{
+    error: "error";
+    pending: "pending";
+    processing: "processing";
+    completed: "completed";
+    processed: "processed";
+    failed: "failed";
+}>;
 type DocumentStatus = z.infer<typeof DocumentStatusSchema>;
 interface UploadDocumentInput {
     /** Company ID to associate the document with */
@@ -200,6 +179,10 @@ declare class DeleganceError extends Error {
     statusCode: number;
     traceId?: string | undefined;
     details?: unknown | undefined;
+    /** Machine-readable `reason` from the error body, when the server sent one. */
+    reason?: string;
+    /** The parsed error body, for fields a caller needs (portalUrl, hint). */
+    body?: Record<string, unknown>;
     constructor(message: string, statusCode: number, traceId?: string | undefined, details?: unknown | undefined);
 }
 declare class AuthenticationError extends DeleganceError {
@@ -215,6 +198,16 @@ declare class RateLimitError extends DeleganceError {
     retryAfter?: number | undefined;
     constructor(message: string, retryAfter?: number | undefined, traceId?: string);
 }
+declare class ForbiddenError extends DeleganceError {
+    constructor(message: string, traceId?: string);
+}
+/**
+ * The server recognised the request but the capability is not live yet
+ * (HTTP 501). Permanent for the current deployment, so it is never retried.
+ */
+declare class NotImplementedError extends DeleganceError {
+    constructor(message: string, traceId?: string);
+}
 
 /**
  * HTTP Client utilities for the Delegance SDK
@@ -229,7 +222,18 @@ interface RequestOptions {
     /** If true, body is FormData and shouldn't be JSON stringified */
     isFormData?: boolean;
 }
-declare const SDK_VERSION = "0.1.0";
+/** Kept equal to package.json "version"; a unit test fails on drift. */
+declare const SDK_VERSION = "0.2.0";
+/**
+ * Canonical default API origin (WS0/WS1 shared constant, the SDK-package
+ * source of truth; the CLI mirror lives in cli/src/utils/config.ts).
+ *
+ * Decided for the 0.2.0 publish (2026-09-24): the prod portal is the default
+ * host. Callers override it with `baseUrl` or DELEGANCE_BASE_URL. Changing
+ * the host is exactly two lines (this constant + the CLI mirror) plus
+ * regenerated docs.
+ */
+declare const DEFAULT_BASE_URL = "https://portal.delegancebrokerage.com";
 declare class HttpClient {
     private config;
     constructor(config: DeleganceClientConfig);
@@ -829,6 +833,49 @@ interface ListPoliciesResponse {
     count: number;
     traceId: string;
 }
+type CancellationReason = 'replaced' | 'business_closed' | 'sold' | 'not_needed' | 'other';
+interface CancellationRequestInput {
+    /** YYYY-MM-DD; coverage ends at 12:01 AM that day. */
+    requestedEffectiveDate: string;
+    reason: CancellationReason;
+    /** Required when reason is 'replaced'. */
+    replacementPolicyId?: string;
+}
+interface CancellationSignInput {
+    signerName: string;
+    signerTitle: string;
+    /** The signer attests they may bind the named insured. Must be true. */
+    attestAuthority: true;
+    /** From the 202 that emailed the code. Omit both to (re)send a code. */
+    stepUpId?: string;
+    /** The 6-digit code from the email. */
+    code?: string;
+}
+/** 202: a code went to the signer's email. 200: signed. */
+type CancellationSignResult = {
+    stepUpRequired: true;
+    stepUpId: string;
+    action: 'sign';
+    channel: 'email';
+    sentTo: string;
+    expiresAt: string | null;
+    requestId: string;
+} | {
+    status: 'signed';
+    requestId: string;
+};
+interface CancellationStatus {
+    id: string;
+    policyId?: string;
+    status: string;
+    requestedEffectiveDate: string;
+    reason: string;
+    /** Claims-made continuity verdict: 'continuous', 'prior_acts_gap', 'unknown', ... */
+    continuity: string;
+    confirmedEffectiveDate?: string | null;
+    confirmationNumber?: string | null;
+    updatedAt?: string;
+}
 declare class PoliciesModule {
     private http;
     constructor(http: HttpClient);
@@ -865,6 +912,28 @@ declare class PoliciesModule {
         policy: Policy;
         coverages: PolicyCoverage[];
     } | null>;
+    /**
+     * 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.
+     */
+    requestCancellation(policyId: string, input: CancellationRequestInput, opts?: {
+        idempotencyKey?: string;
+    }): Promise<{
+        request: CancellationStatus;
+        signatureUrl: string;
+        signEndpoint?: string;
+    }>;
+    /**
+     * 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`.
+     */
+    signCancellation(requestId: string, input: CancellationSignInput, opts?: {
+        idempotencyKey?: string;
+    }): Promise<CancellationSignResult>;
+    /** One cancellation request's status. */
+    getCancellation(requestId: string): Promise<CancellationStatus>;
 }
 
 /**
@@ -1136,9 +1205,12 @@ interface RotateResult {
     rotationId: string;
     status: 'rotating';
 }
+/** Scopes the server accepts. `appetite:read` and `mcp:*` are opt-in and never implied. */
+type ApiKeyScope = 'read' | 'write' | 'admin' | 'appetite:read' | 'mcp:read' | 'mcp:orin';
+declare const API_KEY_SCOPES: readonly ApiKeyScope[];
 interface CreateApiKeyInput {
     name: string;
-    scopes: ('read' | 'write' | 'admin')[];
+    scopes: ApiKeyScope[];
     expiresInDays?: number;
 }
 interface ListApiKeysOptions {
@@ -1492,6 +1564,23 @@ interface OnboardingStatus {
      */
     nextStep: OnboardingNextStep | null;
 }
+/** The five onboarding states of the frozen WS1 contract. */
+type OnboardingState = 'created' | 'awaiting_verification' | 'documents_pending' | 'processing' | 'ready';
+/** Data payload of `GET /api/v1/onboarding/state`. */
+interface OnboardingStateData {
+    state: OnboardingState;
+    verified: boolean;
+    capabilities: string[];
+    verification: {
+        challengeIssued: boolean;
+        sentTo: string | null;
+    };
+    documents: {
+        total: number;
+        processing: number;
+        processed: number;
+    };
+}
 declare class OnboardingModule {
     private http;
     constructor(http: HttpClient);
@@ -1514,6 +1603,749 @@ declare class OnboardingModule {
      * ```
      */
     status(): Promise<OnboardingStatus>;
+    /** Poll the canonical onboarding state machine. Callable pre-verification. */
+    state(): Promise<OnboardingStateData>;
+    /**
+     * 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.
+     */
+    requestVerification(): Promise<{
+        state: OnboardingState;
+        sentTo: string;
+    }>;
+    /** Poll state() until `target` is reached or `timeoutMs` elapses. */
+    waitForState(target: OnboardingState, options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<OnboardingStateData>;
+}
+
+/**
+ * Appetite Module
+ *
+ * Carrier appetite matching: which carriers will write a given risk.
+ *
+ * Contract (POST /api/v1/appetite/match):
+ * - warm cache hit -> 200 with the full validated result
+ * - cold           -> 202 with a job id; poll GET /api/v1/appetite/match/:jobId
+ *
+ * Requires an API key carrying the `appetite:read` scope. That scope is not
+ * implied by `read` or `write`. The endpoint answers 404 while the partner
+ * API is disabled for the deployment.
+ */
+
+interface AppetiteMatchInput {
+    /** Two-letter US state code (required). */
+    state: string;
+    /** One of industry, businessDescription, naicsCode, or sicCode is required. */
+    industry?: string;
+    businessDescription?: string;
+    naicsCode?: string;
+    sicCode?: string;
+    coverageTypes?: string[];
+    carriers?: string[];
+    marketSize?: 'Small Business' | 'Middle Market';
+    productFilter?: 'off' | 'boost' | 'strict';
+    annualRevenue?: number;
+    annualPayroll?: number;
+    propertyValue?: number;
+    /** Callers may only raise the quality floor. */
+    minFit?: 'possible' | 'strong';
+    topK?: number;
+    minScore?: number;
+}
+interface AppetiteMatch {
+    carrier: string;
+    classDescription: string;
+    industryCategory: string;
+    product: string;
+    appetite: 'Target' | 'Acceptable' | 'Limited' | 'Not Available';
+    score: number;
+    matchDetails: {
+        codeMatchScore: number;
+        semanticScore: number;
+        stateMatch: boolean;
+    };
+    classCode: string;
+    sicCode: string;
+    naicsCode: string;
+    limits: string;
+    notes: string;
+    marketSize: string;
+}
+interface CarrierAppetiteResult {
+    carrier: string;
+    overallStatus: 'acceptable' | 'targeted' | 'limited' | 'declined' | 'unknown';
+    confidence: number;
+    bestMatch: AppetiteMatch;
+    allMatches: AppetiteMatch[];
+    productsAvailable: string[];
+    warnings: string[];
+}
+interface AppetiteMatchResult {
+    matches: AppetiteMatch[];
+    carrierResults: CarrierAppetiteResult[];
+    suggestedCarriers: string[];
+    warnings: string[];
+    metadata: Record<string, unknown> & {
+        validated?: boolean;
+    };
+}
+/** Result of `appetite.match()`: either a finished result or a queued job. */
+type AppetiteMatchStart = ({
+    status: 'succeeded';
+    cached: true;
+    jobId: null;
+    traceId: string;
+} & AppetiteMatchResult) | {
+    status: 'queued';
+    jobId: string;
+    statusUrl: string;
+    estimatedSeconds: number;
+    traceId: string;
+};
+type AppetiteJobStatus = {
+    status: 'queued' | 'running';
+    jobId: string;
+    estimatedSeconds: number;
+    traceId: string;
+} | ({
+    status: 'succeeded';
+    jobId: string;
+    cached: false;
+    traceId: string;
+} & AppetiteMatchResult) | {
+    status: 'failed';
+    jobId: string;
+    errorCode: string;
+    retryable: boolean;
+    retryAfterSeconds?: number;
+    traceId: string;
+};
+interface WaitForMatchOptions {
+    intervalMs?: number;
+    timeoutMs?: number;
+}
+declare class AppetiteModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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);
+     * ```
+     */
+    match(input: AppetiteMatchInput): Promise<AppetiteMatchStart>;
+    /** Read a match job. Unknown, expired, and other-tenant ids all raise NotFoundError. */
+    getMatch(jobId: string): Promise<AppetiteJobStatus>;
+    /**
+     * Poll a job until it succeeds. Throws on a failed job (with the sanitized
+     * errorCode) or on timeout.
+     */
+    waitForMatch(jobId: string, options?: WaitForMatchOptions): Promise<Extract<AppetiteJobStatus, {
+        status: 'succeeded';
+    }>>;
+}
+
+/**
+ * Leads Module
+ *
+ * Send a prospect business to Delegance (POST /api/v1/leads). Needs the
+ * `write` scope. Idempotent on `externalId`, and a lead whose contact email
+ * already belongs to a company returns that company instead of a duplicate.
+ */
+
+interface LeadAddress {
+    street: string;
+    suite?: string;
+    city: string;
+    /** Two-letter state code. */
+    state: string;
+    /** 5-digit or ZIP+4. */
+    zip: string;
+}
+interface CreateLeadInput {
+    name: string;
+    contactEmail: string;
+    legalName?: string;
+    industry?: string;
+    contactPhone?: string;
+    website?: string;
+    companySize?: string;
+    description?: string;
+    sicCode?: string;
+    naicsCode?: string;
+    state?: string;
+    address?: LeadAddress;
+    externalId?: string;
+    source?: string;
+    sourceDetail?: Record<string, unknown>;
+    notes?: string;
+    metadata?: Record<string, unknown>;
+}
+interface CreateLeadResult {
+    success: boolean;
+    companyId: string;
+    message: string;
+    traceId: string;
+}
+declare class LeadsModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a lead.
+     *
+     * @example
+     * ```typescript
+     * const { companyId } = await client.leads.create({
+     *   name: 'Riverbend Bakery',
+     *   contactEmail: 'owner@riverbend.example',
+     *   state: 'TX',
+     *   externalId: 'crm-4411',
+     * });
+     * ```
+     */
+    create(input: CreateLeadInput): Promise<CreateLeadResult>;
+}
+
+/**
+ * Instant Quotes Module: real carrier premiums over the API.
+ *
+ * Needs a key with a person behind it (from `delegance signup`, or created in
+ * the portal while signed in). Flow: `start` returns the questions, `submit`
+ * files the answers with the carriers, `status` / `waitForQuotes` return
+ * premiums as carriers answer, `bind` requests a bind on one offer.
+ *
+ * `submit` and `bind` send an Idempotency-Key. Pass your own to make a retry
+ * across process restarts land on the same request; otherwise one is made per
+ * call and reused by the SDK's own retries.
+ */
+
+interface InstantQuestionOption {
+    value: string;
+    label: string;
+}
+interface InstantQuestion {
+    id: string;
+    label: string;
+    type: string;
+    options?: InstantQuestionOption[];
+    required: boolean;
+    group?: string;
+    /** Answered from the insured's own account data. Shown and editable. */
+    prefill?: unknown;
+    /** Inferred by a source. Counts only after the insured confirms it. */
+    suggested?: {
+        value: unknown;
+        route?: string;
+        confidence?: string;
+    };
+    /** Required only while visible. */
+    requiredIfShown?: boolean;
+    /** Shown only when the named question's answer is one of `equals`. */
+    showIf?: {
+        questionId: string;
+        equals: string[];
+    };
+    [key: string]: unknown;
+}
+interface InstantSession {
+    submissionId: string;
+    sessionVersion: string;
+    decision: string;
+    eligibleCarriers: {
+        carrierId: string;
+        name: string;
+    }[];
+    questions: InstantQuestion[];
+}
+interface InstantSubmitResult {
+    quotes: {
+        carrierId: string;
+        carrierName: string;
+        premium: number | null;
+        status: string;
+    }[];
+    /** `missing` names the value that would bring a carrier dropped by a data floor back. */
+    partialFailures: {
+        carrierId: string;
+        reason: string;
+        missing?: string;
+    }[];
+    acordCoverages: string[];
+    status: 'submitted' | 'acord_pending' | 'no_carriers';
+    /** The broker task, when ACORD lines were queued (`acord_pending`). */
+    brokerTaskId?: string;
+    /** On a replace: the earlier requests closed on our side, per coverage. */
+    superseded?: {
+        policyType: string;
+        submissionIds: string[];
+        carriers: string[];
+    }[];
+    /** On a replace: coverages whose earlier request stayed open (nothing new was filed for them). */
+    restored?: string[];
+    replaceNotice?: string;
+}
+interface CarrierQuote {
+    opportunityId: string;
+    carrierId: string;
+    carrierName: string;
+    coverage: string | null;
+    state: string;
+    marketStatus: string;
+    premium: number | null;
+    quoteNumber: string | null;
+    bindable: boolean | null;
+}
+interface InstantQuoteStatus {
+    submissionId: string;
+    coverages: string[];
+    expiresAt: string | null;
+    submitted: boolean;
+    submitStatus: 'not_submitted' | 'in_progress' | 'completed';
+    carrierQuotes: CarrierQuote[];
+    allCarriersResolved: boolean;
+    awaitingBrokerReviewCount: number;
+    /** The newest broker task on this submission; null when none. Absent when the server could not read it. */
+    brokerReview?: {
+        taskId: string;
+        status: string;
+        createdAt: string;
+    } | null;
+}
+/** ACORD questions a broker needs after a `no_carriers` result. */
+interface BrokerHandoffQuestions {
+    submissionId: string;
+    coverages: string[];
+    questions: InstantQuestion[];
+    /** True when this submission is already with a broker; `questions` is empty. */
+    alreadyHandedOff: boolean;
+    brokerTaskId?: string | null;
+}
+interface BrokerHandoffResult {
+    status: 'broker_review';
+    submissionId: string;
+    brokerTaskId: string | null;
+    coverages: string[];
+    /** Required questions left blank. The broker asks them. */
+    unansweredRequired: number;
+    alreadyHandedOff: boolean;
+}
+interface BindRequestResult {
+    bindRequestId: string;
+    status: string;
+    carrierName: string;
+    coverage: string;
+    premium: number | null;
+    existing: boolean;
+    next: string;
+    /** Fast bind only: 'A' opens the carrier's own checkout, 'C' goes to a broker. */
+    tier?: 'A' | 'C';
+    /** Tier C: why the offer could not use the carrier checkout. */
+    reasons?: string[];
+    /** Tier A: the carrier's checkout page. The policy is bound only when the carrier confirms. */
+    checkoutUrl?: string;
+}
+/** The first fast-bind call emails a code; send it back with `stepUpId`. */
+interface BindStepUpRequired {
+    stepUpRequired: true;
+    stepUpId: string;
+    channel: 'email';
+    sentTo: string;
+    expiresAt: string | null;
+}
+interface FastBindInput {
+    /** You confirm the application answers are accurate. Required by fast bind. */
+    attest?: boolean;
+    stepUpId?: string;
+    code?: string;
+    idempotencyKey?: string;
+}
+declare class InstantQuotesModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * `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.
+     */
+    start(coverages: string[], opts?: {
+        fresh?: boolean;
+    }): Promise<InstantSession>;
+    submit(input: {
+        submissionId: string;
+        sessionVersion: string;
+        answers: Record<string, unknown>;
+        /**
+         * Close the earlier request for the same coverage and re-quote. Without
+         * it, a submit while one is with carriers returns 409
+         * `active_request_exists`. A carrier may still see the earlier
+         * application: CoverForce has no withdraw call.
+         */
+        replace?: boolean;
+    }, opts?: {
+        idempotencyKey?: string;
+    }): Promise<InstantSubmitResult>;
+    status(submissionId: string): Promise<InstantQuoteStatus>;
+    /** Polls `status` until every visible carrier resolved, or the timeout. */
+    waitForQuotes(submissionId: string, opts?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+        onPoll?: (s: InstantQuoteStatus) => void;
+    }): Promise<InstantQuoteStatus>;
+    /**
+     * 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.
+     */
+    brokerHandoffQuestions(submissionId: string, instantAnswers?: Record<string, unknown>): Promise<BrokerHandoffQuestions>;
+    /**
+     * 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.
+     */
+    brokerHandoff(submissionId: string, input: {
+        answers: Record<string, unknown>;
+        instantAnswers?: Record<string, unknown>;
+        complete?: boolean;
+    }, opts?: {
+        idempotencyKey?: string;
+    }): Promise<BrokerHandoffResult>;
+    /** Requests a bind on one offer. A licensed broker reviews it; nothing is charged. */
+    bind(submissionId: string, opportunityId: string, opts?: {
+        idempotencyKey?: string;
+    }): Promise<BindRequestResult>;
+    /**
+     * 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.
+     */
+    bindWithStepUp(submissionId: string, opportunityId: string, input?: FastBindInput): Promise<BindRequestResult | BindStepUpRequired>;
+}
+
+/**
+ * Payments Module: premium payment requests and Stripe checkout links.
+ *
+ * A payment request exists after a broker reviews a bind and records the
+ * carrier's final premium. `checkout` returns a hosted Stripe URL to pay it.
+ */
+
+interface PaymentRequest {
+    id: string;
+    /** Cents. */
+    amount: number;
+    currency: string;
+    description: string | null;
+    status: string;
+    dueDate?: string;
+    createdAt: string;
+    payable: boolean;
+}
+declare class PaymentsModule {
+    private http;
+    constructor(http: HttpClient);
+    list(): Promise<PaymentRequest[]>;
+    checkout(paymentRequestId: string, opts?: {
+        idempotencyKey?: string;
+    }): Promise<{
+        checkoutUrl: string;
+    }>;
+}
+
+/**
+ * Bonds Module: surety bond quotes.
+ *
+ * `start` matches the bond and returns its questions, `answer` submits them
+ * (starting pricing when complete), `status` returns the premium and the
+ * surety's apply link. Buying a bond is never automated: a quoted bond hands
+ * off to the surety's apply page.
+ *
+ * Responses pass through the bond quote service as-is (snake_case fields such
+ * as `session_id`, `missing_required`, `apply_url`).
+ */
+
+interface StartBondQuoteInput {
+    /** Two-letter state, e.g. 'TX'. */
+    state?: string;
+    /** Bond name or keyword, e.g. 'notary', 'contractor license'. */
+    bondName?: string;
+    entityId?: string;
+    contractAmount?: string | number;
+    bondAmount?: string | number;
+}
+type BondToolResult = Record<string, unknown>;
+declare class BondsModule {
+    private http;
+    constructor(http: HttpClient);
+    start(input: StartBondQuoteInput): Promise<BondToolResult>;
+    answer(sessionId: string, answers: Record<string, unknown>, opts?: {
+        idempotencyKey?: string;
+    }): Promise<BondToolResult>;
+    status(sessionId: string): Promise<BondToolResult>;
+}
+
+/**
+ * Claims Module: file and track claims.
+ *
+ * Needs a key with the `claims:write` scope, minted by `delegance signup` or
+ * by a signed-in portal user. The claims disclaimer must be accepted once in
+ * the portal by the key's user; until then `file` throws with
+ * reason `gate_not_acknowledged` and `body.portalUrl`.
+ */
+
+interface ClaimSummary {
+    claimId: string;
+    status: 'open' | 'in_progress' | 'resolved' | string;
+    summary: string | null;
+    incidentDate: string | null;
+    policyId: string | null;
+    openedAt: string;
+    lastActivityAt: string;
+    resolvedAt: string | null;
+}
+interface FileClaimInput {
+    description: string;
+    /** YYYY-MM-DD. */
+    incidentDate?: string;
+    policyId?: string;
+}
+declare class ClaimsModule {
+    private http;
+    constructor(http: HttpClient);
+    file(input: FileClaimInput, opts?: {
+        idempotencyKey?: string;
+    }): Promise<ClaimSummary & {
+        created: boolean;
+        portalUrl: string;
+        message: string;
+    }>;
+    list(opts?: {
+        status?: 'open' | 'in_progress' | 'resolved';
+        limit?: number;
+    }): Promise<ClaimSummary[]>;
+    get(claimId: string): Promise<ClaimSummary>;
+}
+
+/**
+ * Feedback Module: report a bug, an idea, or a question to Delegance.
+ *
+ * Any API key may report. The server scrubs credentials from the message and
+ * keeps only known context fields, but send no secrets: the context is for
+ * the command name, exit code, trace id, and versions.
+ */
+
+type FeedbackType = 'bug' | 'idea' | 'question';
+/** Matches the server cap; longer messages are refused, not cut. */
+declare const FEEDBACK_MESSAGE_MAX = 500;
+interface FeedbackContext {
+    /** Command path only, e.g. "quote submit". Never arguments. */
+    command?: string;
+    exitCode?: number;
+    /** The traceId from an error response, if the failure returned one. */
+    traceId?: string;
+    /** ISO timestamp of the failed command. */
+    at?: string;
+    cliVersion?: string;
+    sdkVersion?: string;
+}
+interface SubmitFeedbackInput {
+    /** Defaults to 'bug'. */
+    type?: FeedbackType;
+    message: string;
+    context?: FeedbackContext;
+}
+declare class FeedbackModule {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 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.
+     */
+    submit(input: SubmitFeedbackInput, opts?: {
+        idempotencyKey?: string;
+    }): Promise<{
+        id: string;
+    }>;
+}
+
+/**
+ * Signup Module: commercial insurance from a terminal, step one.
+ *
+ * Signup is a device-code exchange. No API key exists yet, so this module
+ * runs unauthenticated except for `enroll` and `requestVerification`, which
+ * use the one-time bootstrap key the signup returns.
+ *
+ *   1. createAccount     unverified company + bootstrap key
+ *   2. enroll            register SHA-256(deviceSecret) against that key
+ *   3. requestVerification  emails the confirm link to the contact email
+ *   4. exchange          poll with the plaintext deviceSecret; after the human
+ *                        clicks the link it returns a user-bound API key
+ *
+ * The device secret never leaves the terminal except to `exchange`, and the
+ * bootstrap key is revoked server-side once the email is confirmed.
+ */
+
+interface CreateAccountInput {
+    name: string;
+    contactEmail: string;
+    industry: string;
+    /** Employee band: '0', '1', '2-10', '11-25', '26-50', '51-100', '100-499', '500+'. */
+    companySize: string;
+    /** One or two sentences on what the business does; feeds carrier class matching. */
+    description?: string;
+    website?: string;
+    contactPhone?: string;
+    address?: {
+        street: string;
+        suite?: string;
+        city: string;
+        state: string;
+        zip: string;
+    };
+}
+interface CreateAccountResult {
+    companyId: string;
+    bootstrapKey: string;
+    /** e.g. 'address_not_saved': the account exists but the server could not store part of it. */
+    warnings?: string[];
+}
+interface EnrollResult {
+    enrollmentId: string;
+    expiresAt: string;
+}
+type ExchangeResult = {
+    status: 'pending';
+} | {
+    status: 'ready';
+    apiKey: string;
+    keyPrefix: string;
+    companyId: string;
+};
+/** 32 random bytes as hex, and its SHA-256. */
+declare function newDeviceSecret(): {
+    secret: string;
+    hash: string;
+};
+declare class SignupModule {
+    private makeHttp;
+    constructor(makeHttp: (apiKey: string) => HttpClient);
+    /** Creates the unverified company. Retries safely: sends an Idempotency-Key. */
+    createAccount(input: CreateAccountInput, opts?: {
+        idempotencyKey?: string;
+    }): Promise<CreateAccountResult>;
+    enroll(bootstrapKey: string, input: {
+        deviceSecretHash: string;
+        firstName: string;
+        lastName: string;
+    }): Promise<EnrollResult>;
+    requestVerification(bootstrapKey: string): Promise<{
+        sentTo?: string;
+    }>;
+    /**
+     * One poll. `pending` until the email link is clicked. Throws with
+     * `reason` = already_collected | account_exists (409) or expired (410).
+     */
+    exchange(enrollmentId: string, deviceSecret: string): Promise<ExchangeResult>;
+    /**
+     * Polls `exchange` until the key is ready or `timeoutMs` passes. A 429 waits
+     * the server's Retry-After and keeps polling.
+     */
+    waitForKey(enrollmentId: string, deviceSecret: string, opts?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+        onPoll?: () => void;
+    }): Promise<ExchangeResult>;
+}
+
+interface PollOptions {
+    timeoutMs?: number;
+    intervalMs?: number;
+    onPoll?: () => void;
+}
+
+/**
+ * Auth Module: sign a terminal in with the browser, and inspect or refresh
+ * the key it holds.
+ *
+ * Browser login is a device authorization (the same device-secret exchange
+ * as signup):
+ *
+ *   1. start      send SHA-256(deviceSecret); get a short code and a portal URL
+ *   2. (human)    a signed-in portal user opens the URL and approves the code
+ *   3. waitForKey poll with the plaintext deviceSecret until the key is ready
+ *
+ * The device secret never leaves the terminal except to the token poll, and
+ * the key can be collected once.
+ */
+
+interface DeviceLoginStart {
+    loginId: string;
+    /** Shown as XXXX-XXXX; the portal page asks the human to match it. */
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete: string;
+    expiresAt: string;
+    /** Seconds between polls. */
+    interval: number;
+}
+type DeviceLoginPoll = {
+    status: 'pending';
+} | {
+    status: 'ready';
+    apiKey: string;
+    keyPrefix: string;
+    companyId: string;
+    scopes: string[];
+    expiresAt: string | null;
+};
+interface ApiKeyInfo {
+    keyPrefix: string;
+    origin: string | null;
+    scopes: string[];
+    companyId: string;
+    userBound: boolean;
+    /** ISO time, or null for a key that never expires. */
+    expiresAt: string | null;
+    /** True for CLI keys, which `refresh()` can extend. */
+    refreshable: boolean;
+    createdAt: string | null;
+}
+declare class DeviceLoginModule {
+    private makeHttp;
+    constructor(makeHttp: (apiKey: string) => HttpClient);
+    start(input: {
+        deviceSecretHash: string;
+        deviceName: string;
+    }): Promise<DeviceLoginStart>;
+    /**
+     * One poll. `pending` until the portal user approves. Throws with `reason`
+     * = access_denied (403), already_collected (409), or expired (410).
+     */
+    poll(loginId: string, deviceSecret: string): Promise<DeviceLoginPoll>;
+    /** Polls until the key is ready or `timeoutMs` passes (then returns `pending`). */
+    waitForKey(loginId: string, deviceSecret: string, opts?: PollOptions): Promise<DeviceLoginPoll>;
+}
+declare class AuthModule {
+    private http;
+    constructor(http: HttpClient);
+    /** The calling key: prefix, origin, scopes, company, and expiry. */
+    keyInfo(): Promise<ApiKeyInfo>;
+    /** Extend a CLI key to 90 days from now. Throws `not_refreshable` (400) for portal keys. */
+    refresh(): Promise<{
+        expiresAt: string;
+    }>;
 }
 
 /**
@@ -1527,7 +2359,7 @@ declare class OnboardingModule {
  *
  * const client = new DeleganceClient({
  *   apiKey: 'dlg_xxx_sk_xxx',
- *   baseUrl: 'https://app.delegance.ai'
+ *   baseUrl: 'https://portal.delegancebrokerage.com'
  * });
  *
  * // Create a company
@@ -1574,6 +2406,22 @@ declare class DeleganceClient {
     readonly knowledge: KnowledgeModule;
     /** Onboarding module for checking developer setup status */
     readonly onboarding: OnboardingModule;
+    /** Appetite module for carrier appetite matching (needs the appetite:read scope) */
+    readonly appetite: AppetiteModule;
+    /** Leads module for sending prospect businesses to Delegance */
+    readonly leads: LeadsModule;
+    /** Instant quotes: questions, carrier premiums, and bind requests */
+    readonly instantQuotes: InstantQuotesModule;
+    /** Premium payment requests and Stripe checkout links */
+    readonly payments: PaymentsModule;
+    /** Surety bond quotes */
+    readonly bonds: BondsModule;
+    /** File and track claims (needs the claims:write scope) */
+    readonly claims: ClaimsModule;
+    /** Report a bug, an idea, or a question to Delegance */
+    readonly feedback: FeedbackModule;
+    /** The calling key: info and refresh */
+    readonly auth: AuthModule;
     /**
      * Create a new Delegance client
      *
@@ -1603,7 +2451,7 @@ declare class DeleganceClient {
  *
  * Reads from:
  * - DELEGANCE_API_KEY - Required API key
- * - DELEGANCE_BASE_URL - Optional base URL (default: https://app.delegance.ai)
+ * - DELEGANCE_BASE_URL - Optional base URL (default: https://portal.delegancebrokerage.com)
  *
  * @example
  * ```typescript
@@ -1612,5 +2460,36 @@ declare class DeleganceClient {
  * ```
  */
 declare function createClientFromEnv(): DeleganceClient;
+/**
+ * Signup runs before any API key exists, so it lives outside DeleganceClient.
+ *
+ * @example
+ * ```typescript
+ * const signup = createSignup();
+ * const { bootstrapKey } = await signup.createAccount({ ... });
+ * ```
+ */
+declare function createSignup(config?: {
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+}): SignupModule;
+/**
+ * Browser login for an existing customer (`delegance auth login`). No API key
+ * yet: the device secret is the credential.
+ *
+ * ```typescript
+ * const login = createDeviceLogin();
+ * const device = newDeviceSecret();
+ * const start = await login.start({ deviceSecretHash: device.hash, deviceName: 'laptop' });
+ * // show start.userCode and open start.verificationUriComplete
+ * const result = await login.waitForKey(start.loginId, device.secret);
+ * ```
+ */
+declare function createDeviceLogin(config?: {
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+}): DeviceLoginModule;
 
-export { type APIKey, type APIResponse, type ApiKey, ApiKeysModule, AuthenticationError, type COI, COIModule, type Carrier, type CertificateHolder, type ChatMessage, ChatModule, type ChatOptions, type ChatResponse, CompaniesModule, type Company, type CompanySize, CompanySizeSchema, type CreateAPIKeyInput, type CreateApiKeyInput, type CreateCompanyInput, CreateCompanySchema, type CreatedAPIKey, type CreatedApiKey, type DailyUsage, type DailyUsageOptions, DeleganceClient, type DeleganceClientConfig, DeleganceError, type Document, type DocumentFacts, type DocumentStatus, DocumentStatusSchema, type DocumentType, DocumentTypeSchema, type DocumentWithExtraction, DocumentsModule, type ExtractedPolicy, type GenerateCOIRequest, type GenerateCOIResponse, type GetPolicyResponse, type GetQuoteResponse, type GetSOVResponse, type IdempotencyOptions, KnowledgeModule, type KnowledgeSearchResult, type ListApiKeysOptions, type ListCOIsResponse, type ListCarriersResponse, type ListCompaniesOptions, type ListDocumentsOptions, type ListNotecardsOptions, type ListPoliciesOptions, type ListPoliciesResponse, type ListQuotesOptions, type ListQuotesResponse, type ListSOVsOptions, type ListSOVsResponse, type MeterUsage, NotFoundError, type Notecard, OnboardingModule, type OnboardingNextStep, type OnboardingStatus, type PaginatedResponse, PoliciesModule, type Policy, type PolicyCoverage, type Quote, type QuoteRequest, QuotesModule, RateLimitError, type RateLimitStatus, type RotateResult, SDK_VERSION, type SOV, type SOVLocation, SOVModule, type SearchInput, type SubmitQuoteResponse, type UploadDocumentInput, type UploadSOVRequest, type UploadSOVResponse, UsageModule, type UsageSummary, ValidationError, type WaitForExtractionOptions, createClientFromEnv };
+export { type APIKey, type APIResponse, API_KEY_SCOPES, type ApiKey, type ApiKeyInfo, type ApiKeyScope, ApiKeysModule, type AppetiteJobStatus, type AppetiteMatch, type AppetiteMatchInput, type AppetiteMatchResult, type AppetiteMatchStart, AppetiteModule, AuthModule, AuthenticationError, type BindRequestResult, type BindStepUpRequired, type BondToolResult, BondsModule, type BrokerHandoffQuestions, type BrokerHandoffResult, type COI, COIModule, type CancellationReason, type CancellationRequestInput, type CancellationSignInput, type CancellationSignResult, type CancellationStatus, type Carrier, type CarrierAppetiteResult, type CarrierQuote, type CertificateHolder, type ChatMessage, ChatModule, type ChatOptions, type ChatResponse, type ClaimSummary, ClaimsModule, CompaniesModule, type Company, type CompanySize, CompanySizeSchema, type CreateAPIKeyInput, type CreateAccountInput, type CreateAccountResult, type CreateApiKeyInput, type CreateCompanyInput, CreateCompanySchema, type CreateLeadInput, type CreateLeadResult, type CreatedAPIKey, type CreatedApiKey, DEFAULT_BASE_URL, type DailyUsage, type DailyUsageOptions, DeleganceClient, type DeleganceClientConfig, DeleganceError, DeviceLoginModule, type DeviceLoginPoll, type DeviceLoginStart, type Document, type DocumentFacts, type DocumentStatus, DocumentStatusSchema, type DocumentType, DocumentTypeSchema, type DocumentWithExtraction, DocumentsModule, type EnrollResult, type ExchangeResult, type ExtractedPolicy, FEEDBACK_MESSAGE_MAX, type FastBindInput, type FeedbackContext, FeedbackModule, type FeedbackType, type FileClaimInput, ForbiddenError, type GenerateCOIRequest, type GenerateCOIResponse, type GetPolicyResponse, type GetQuoteResponse, type GetSOVResponse, type IdempotencyOptions, type InstantQuestion, type InstantQuestionOption, type InstantQuoteStatus, InstantQuotesModule, type InstantSession, type InstantSubmitResult, KnowledgeModule, type KnowledgeSearchResult, type LeadAddress, LeadsModule, type ListApiKeysOptions, type ListCOIsResponse, type ListCarriersResponse, type ListCompaniesOptions, type ListDocumentsOptions, type ListNotecardsOptions, type ListPoliciesOptions, type ListPoliciesResponse, type ListQuotesOptions, type ListQuotesResponse, type ListSOVsOptions, type ListSOVsResponse, type MeterUsage, NotFoundError, NotImplementedError, type Notecard, OnboardingModule, type OnboardingNextStep, type OnboardingState, type OnboardingStateData, type OnboardingStatus, type PaginatedResponse, type PaymentRequest, PaymentsModule, PoliciesModule, type Policy, type PolicyCoverage, type Quote, type QuoteRequest, QuotesModule, RateLimitError, type RateLimitStatus, type RotateResult, SDK_VERSION, type SOV, type SOVLocation, SOVModule, type SearchInput, SignupModule, type StartBondQuoteInput, type SubmitFeedbackInput, type SubmitQuoteResponse, type UploadDocumentInput, type UploadSOVRequest, type UploadSOVResponse, UsageModule, type UsageSummary, ValidationError, type WaitForExtractionOptions, type WaitForMatchOptions, createClientFromEnv, createDeviceLogin, createSignup, newDeviceSecret };