@signaliz/sdk 1.0.52 → 1.0.54

package/README.md

@@ -1,6 +1,6 @@
 # @signaliz/sdk
 
-Typed JavaScript/TypeScript access to the four Signaliz products.
+Typed JavaScript/TypeScript access to all five core products in Signaliz.
 
 ```bash
 npm install @signaliz/sdk
@@ -12,6 +12,7 @@ Production REST endpoints:
 - `https://api.signaliz.com/functions/v1/api/v1/verify-email`
 - `https://api.signaliz.com/functions/v1/api/v1/company-signals`
 - `https://api.signaliz.com/functions/v1/api/v1/signal-to-copy`
+- `https://api.signaliz.com/functions/v1/api/v1/signals`
 
 ```ts
 import { Signaliz } from '@signaliz/sdk';
@@ -59,6 +60,19 @@ const signals = await signaliz.enrichCompanySignals({
 console.log(signals.signals[0].evidencePublishedDate);
 console.log(signals.signals[0].signalFeedSource, signals.signals[0].derived);
 
+// Query-first discovery returns distinct companies with dated source evidence.
+// The first response is usually queued; resume only the returned run ID.
+const signalDiscovery = await signaliz.discoverSignals({
+  query: 'companies that just got funded',
+  limit: 100,
+  sources: ['web', 'news'],
+});
+const completedDiscovery = signalDiscovery.signalSearchRunId
+  ? await signaliz.discoverSignals({ signalSearchRunId: signalDiscovery.signalSearchRunId })
+  : signalDiscovery;
+console.log(completedDiscovery.signals[0]?.company.domain);
+console.log(completedDiscovery.costGuardrail?.costPerQualifiedSignalUsd);
+
 const copy = await signaliz.signalToCopy({
   companyDomain: 'example.com',
   personName: 'Jane Doe',
@@ -74,7 +88,7 @@ const copy = await signaliz.signalToCopy({
 // methods return complete data or throw a terminal error in this same call.
 ```
 
-All four products support bounded batch execution over the same REST endpoints.
+The four row-oriented products support bounded batch execution over the same REST endpoints.
 Results stay in input order, failures are isolated per item, and concurrency is
 limited to `1-50` (default `10`):
 
@@ -100,7 +114,7 @@ For an ambiguous single request or batch submission failure, retry with the
 same `idempotencyKey` to recover the original request or durable job without duplicate
 work.
 
-Each batch accepts up to 5,000 items. For all four core products, batches larger
+Each batch accepts up to 5,000 items. For the four row-oriented core products, batches larger
 than 25 use one recoverable REST job; the SDK waits for completion and retrieves
 every result page before returning, so callers never receive queued work or
 polling instructions. Find Email, Verify Email, and Signal to Copy use 500-row
@@ -117,6 +131,16 @@ explicitly requests `skipCache` or `enableDeepSearch`, the SDK preserves that
 fresh-research behavior by using synchronous client-side chunks of at most 25.
 Signal to Copy also shares company research across copy recipients.
 
+Signals Everything is query-first rather than a row batch. It defaults to 100
+distinct companies and supports up to 1,000. Every returned signal contains a
+company name, company domain, dated evidence, and a source URL. The typed
+`costGuardrail` reports both projected and observed source acquisition cost;
+Signaliz returns signals only when cost stays strictly below $0.01 per qualified
+company. A request is a ceiling, not a promise: it can return fewer results
+when public evidence cannot verify both a date and company identity. It is
+included on Team and Agency plans and can be resumed with
+`signalSearchRunId` without duplicate source acquisition.
+
 Company Signal Enrichment defaults `online` and `enableDeepSearch` to `true`
 unless the caller explicitly disables them. Its `searchMode` defaults to
 `balanced`; use `fast` for the primary low-latency search lane only or
@@ -129,8 +153,8 @@ only when fresh or deeper research is required.
 Unclassified evidence is returned by signal enrichment but is not used to
 generate outreach copy.
 Each normalized signal keeps `date` separate from crawl-time `detectedAt` and
-also exposes `datePrecision`, `hasSpecificDate`, `sourceProvenance`,
-`entityConfidence`, `classification`, `derived`, `evidencePublishedDate`,
-`signalFeedSource`, and the provider `metadata` needed for integrity audits.
+also exposes customer-facing classification fields such as `datePrecision`,
+`signalFamily`, `eventType`, `eventLabel`, and `classification`. Provider,
+billing, cache, routing, and validation internals are intentionally omitted.
 
 `listTools()` and `health()` are connection helpers, not additional products.

package/dist/{chunk-IFHOCPIP.mjs → chunk-W4JH6JJA.mjs}

@@ -39,7 +39,11 @@ function publicRetryDetails(body) {
   const details = {
     ...body?.retry_eligible !== void 0 ? { retry_eligible: body.retry_eligible } : {},
     ...body?.retry_after !== void 0 ? { retry_after: body.retry_after } : {},
-    ...body?.retry_after_seconds !== void 0 ? { retry_after_seconds: body.retry_after_seconds } : {}
+    ...body?.retry_after_seconds !== void 0 ? { retry_after_seconds: body.retry_after_seconds } : {},
+    ...body?.run_id !== void 0 ? { run_id: body.run_id } : {},
+    ...body?.signal_run_id !== void 0 ? { signal_run_id: body.signal_run_id } : {},
+    ...body?.company_signal_run_id !== void 0 ? { company_signal_run_id: body.company_signal_run_id } : {},
+    ...body?.resume_context_persisted !== void 0 ? { resume_context_persisted: body.resume_context_persisted } : {}
   };
   return Object.keys(details).length > 0 ? details : void 0;
 }
@@ -464,6 +468,14 @@ var Signaliz = class {
     assertTerminalSignalResponse(data, "Company Signals");
     return normalizeCompanySignalResult(params, data);
   }
+  async discoverSignals(params) {
+    validateSignalDiscoveryParams(params);
+    const data = await this.client.post(
+      "api/v1/signals",
+      signalDiscoveryRequestBody(params)
+    );
+    return normalizeSignalDiscoveryResult(params, data);
+  }
   async enrichCompanies(companies, options) {
     validateBatchSize(companies);
     companies.forEach((params) => validateCoreProductMaxWaitMs(params.maxWaitMs));
@@ -524,10 +536,7 @@ var Signaliz = class {
       request: signalToCopyRequestBody(params)
     }));
     const uniqueRequests = deduplicated.uniqueItems;
-    const requiresFreshResearch = uniqueRequests.some(
-      (request) => request.skipCache === true || request.enableDeepSearch === true
-    );
-    const uniqueResults = uniqueRequests.length > 25 && !requiresFreshResearch ? await this.runRecoverableSignalCopyBatch(uniqueRequests, options) : await this.runSignalCopyBatchChunks(uniqueRequests, options);
+    const uniqueResults = await this.runSignalCopyBatchChunks(uniqueRequests, options);
     const results = requests.map((_, index) => ({
       ...uniqueResults[deduplicated.sourceIndexByInput[index]],
       index
@@ -558,7 +567,7 @@ var Signaliz = class {
     for (let offset = 0; offset < uniqueRequests.length; offset += 25) {
       chunks.push({ offset, requests: uniqueRequests.slice(offset, offset + 25) });
     }
-    const { serverConcurrency, chunkConcurrency } = batchConcurrencyPlan(options);
+    const { serverConcurrency, chunkConcurrency } = batchConcurrencyPlan(options, 25, 25);
     const chunkBatch = await runBatch(
       chunks,
       (chunk) => this.runSignalCopyBatchChunk(chunk.requests, serverConcurrency),
@@ -653,35 +662,6 @@ var Signaliz = class {
     if (seen.size !== requests.length) throw new Error(`${label} batch returned incomplete indexed results`);
     return rows;
   }
-  async runRecoverableSignalCopyBatch(requests, options) {
-    const rows = await this.runRecoverableCoreBatchJob(
-      "api/v1/signal-to-copy",
-      requests.map(signalToCopyRequestBody),
-      "Signal to Copy",
-      100,
-      20 * 6e4,
-      options?.idempotencyKey
-    );
-    const results = new Array(requests.length);
-    for (const row of rows) {
-      const index = Number(row.index);
-      if (recoverableJobRowFailed(row)) {
-        results[index] = batchItemFailure(
-          index,
-          row.error || row._error || row.message || row.failure_reason || "Signal to Copy item failed",
-          row
-        );
-        continue;
-      }
-      try {
-        assertTerminalSignalResponse(row, "Signal to Copy");
-        results[index] = { index, success: true, data: normalizeSignalToCopyResult(row) };
-      } catch (error) {
-        results[index] = batchItemFailure(index, error instanceof Error ? error.message : String(error), row);
-      }
-    }
-    return results;
-  }
   async runSignalCopyBatchChunk(requests, concurrency, rowRateLimitAttempt = 0) {
     const results = new Array(requests.length);
     const rateLimited = [];
@@ -731,12 +711,11 @@ var Signaliz = class {
     return results;
   }
   async runCoreBatchRound(path, tasks, options, rowRateLimitAttempt = 0) {
-    const { serverConcurrency, chunkConcurrency } = batchConcurrencyPlan(options);
+    const { serverConcurrency, chunkConcurrency } = path === "api/v1/company-signals" ? batchConcurrencyPlan(options, 25, 25) : batchConcurrencyPlan(options);
     const deduplicated = dedupeExactBatchItems(tasks, (task) => JSON.stringify(task.request));
     const uniqueTasks = deduplicated.uniqueItems;
-    const recoverableBatch = path === "api/v1/find-email" ? { label: "Find Email", pageSize: 500, maxWaitMs: 20 * 6e4 } : path === "api/v1/verify-email" ? { label: "Verify Email", pageSize: 500, maxWaitMs: 20 * 6e4 } : path === "api/v1/company-signals" ? { label: "Company Signals", pageSize: 25, maxWaitMs: 20 * 6e4 } : void 0;
-    const containsSignalRunRecovery = path === "api/v1/company-signals" && uniqueTasks.some((task) => Boolean(task.request.signal_run_id));
-    if (recoverableBatch && uniqueTasks.length > 25 && !containsSignalRunRecovery) {
+    const recoverableBatch = path === "api/v1/find-email" ? { label: "Find Email", pageSize: 500, maxWaitMs: 20 * 6e4 } : path === "api/v1/verify-email" ? { label: "Verify Email", pageSize: 500, maxWaitMs: 20 * 6e4 } : void 0;
+    if (path !== "api/v1/company-signals" && recoverableBatch && uniqueTasks.length > 25) {
       const rows = await this.runRecoverableCoreBatchJob(
         path,
         uniqueTasks.map((task) => task.request),
@@ -1001,6 +980,7 @@ function companySignalRequestBody(params) {
     enable_outreach_intelligence: params.enableOutreachIntelligence,
     enable_predictive_intelligence: params.enablePredictiveIntelligence,
     skip_cache: params.skipCache,
+    include_candidate_evidence: params.includeCandidateEvidence,
     wait_for_result: true,
     max_wait_ms: params.maxWaitMs,
     dry_run: params.dryRun,
@@ -1018,7 +998,6 @@ function normalizeCompanySignalResult(params, data) {
       domain: data.company?.domain ?? params.companyDomain ?? null
     },
     signals: rawSignals.map((signal) => {
-      const metadata = signal.metadata && typeof signal.metadata === "object" && !Array.isArray(signal.metadata) ? signal.metadata : void 0;
       return {
         id: signal.id,
         title: signal.title ?? "",
@@ -1027,43 +1006,160 @@ function normalizeCompanySignalResult(params, data) {
         date: signal.date ?? null,
         detectedAt: signal.detected_at ?? null,
         datePrecision: signal.date_precision,
-        hasSpecificDate: signal.has_specific_date ?? metadata?.has_specific_date,
         sourceUrl: signal.source_url ?? signal.url ?? null,
         sourceType: signal.source_type,
-        sourceProvenance: signal.source_provenance,
         confidence: signal.confidence ?? signal.confidence_score ?? null,
-        entityConfidence: signal.entity_confidence ?? metadata?.entity_confidence ?? null,
         signalFamily: signal.signal_family,
         eventType: signal.signal_event_type,
         eventLabel: signal.signal_event_label,
-        classification: signal.signal_classification ?? null,
-        derived: signal.derived === true,
-        evidencePublishedDate: signal.evidence_published_date ?? metadata?.evidence_published_date ?? null,
-        signalFeedSource: signal.signal_feed_source ?? metadata?.signal_feed_source,
-        metadata
+        classification: signal.signal_classification ?? null
       };
     }),
     signalCount: data.signal_count ?? data.total_signals ?? rawSignals.length,
     signalSummary: data.signal_summary ?? null,
-    signalSummarySource: data.signal_summary_source,
     intelligence: data.intelligence ?? null,
     copyFuel: data.copy_fuel ?? null,
     evidenceValidation: data.evidence_validation,
-    evidenceSources: data.evidence_sources,
-    credits: data.credits,
-    creditsUsed: data.credits_used,
-    costUsd: data.cost_usd,
-    billingMetadata: data.billing_metadata,
-    resultReturnedFrom: data.result_returned_from,
-    cacheHit: data.cache_hit,
-    freshEnrichmentUsed: data.fresh_enrichment_used,
-    liveProviderCalled: data.live_provider_called,
-    aiProviderCalled: data.ai_provider_called,
-    byoAiUsed: data.byo_ai_used,
-    metadata: data.metadata,
+    evidenceSources: data.metadata?.evidence_sources ?? data.evidence_sources,
+    evidenceCount: data.evidence_count,
+    evidenceCountTotal: data.evidence_count_total,
+    evidenceSourcesOmitted: data.evidence_sources_omitted,
+    evidenceScope: data.evidence_scope,
     raw: data
   };
 }
+var SIGNAL_DISCOVERY_SOURCES = /* @__PURE__ */ new Set(["web", "news"]);
+var SIGNAL_DISCOVERY_STATUSES = /* @__PURE__ */ new Set([
+  "planned",
+  "queued",
+  "processing",
+  "completed",
+  "completed_with_warnings",
+  "failed"
+]);
+function validateSignalDiscoveryParams(params) {
+  const runId = typeof params.signalSearchRunId === "string" ? params.signalSearchRunId.trim() : "";
+  const query = typeof params.query === "string" ? params.query.trim() : "";
+  if (!runId && !query) {
+    throw new TypeError("Signals Everything requires query or signalSearchRunId");
+  }
+  if (query && (query.length < 2 || query.length > 2e3)) {
+    throw new RangeError("query must contain between 2 and 2000 characters");
+  }
+  if (params.limit !== void 0 && (!Number.isInteger(params.limit) || params.limit < 1 || params.limit > 1e3)) {
+    throw new RangeError("limit must be an integer between 1 and 1000");
+  }
+  if (params.lookbackDays !== void 0 && (!Number.isInteger(params.lookbackDays) || params.lookbackDays < 1 || params.lookbackDays > 365)) {
+    throw new RangeError("lookbackDays must be an integer between 1 and 365");
+  }
+  if (params.sources !== void 0 && (!Array.isArray(params.sources) || params.sources.length < 1 || params.sources.length > 2 || params.sources.some((source) => !SIGNAL_DISCOVERY_SOURCES.has(source)))) {
+    throw new TypeError("sources must contain only web or news");
+  }
+}
+function signalDiscoveryRequestBody(params) {
+  const runId = typeof params.signalSearchRunId === "string" ? params.signalSearchRunId.trim() : "";
+  if (runId) {
+    return compact({
+      signal_search_run_id: runId,
+      dry_run: params.dryRun,
+      idempotency_key: params.idempotencyKey
+    });
+  }
+  return compact({
+    query: params.query?.trim(),
+    limit: params.limit ?? 100,
+    sources: params.sources,
+    lookback_days: params.lookbackDays,
+    dry_run: params.dryRun,
+    idempotency_key: params.idempotencyKey
+  });
+}
+function normalizeSignalDiscoveryResult(params, data) {
+  const rawSignals = Array.isArray(data.signals) ? data.signals : [];
+  const rawStatus = String(data.status || "").toLowerCase();
+  const status = SIGNAL_DISCOVERY_STATUSES.has(rawStatus) ? rawStatus : rawSignals.length > 0 ? "completed" : "failed";
+  const signals = rawSignals.map(normalizeSignalDiscoverySignal);
+  return {
+    success: data.success !== false,
+    status,
+    capability: "signals_everything",
+    signalSearchRunId: String(data.signal_search_run_id ?? params.signalSearchRunId ?? ""),
+    query: String(data.query ?? params.query ?? ""),
+    requestedCount: Number(data.requested_count ?? params.limit ?? 100),
+    nextPollAfterSeconds: typeof data.next_poll_after_seconds === "number" ? data.next_poll_after_seconds : void 0,
+    signals,
+    signalCount: signals.length,
+    sourceLanes: Array.isArray(data.source_lanes) ? data.source_lanes.filter((lane) => typeof lane === "string") : void 0,
+    evidenceValidation: data.evidence_validation && typeof data.evidence_validation === "object" ? data.evidence_validation : void 0,
+    costGuardrail: normalizeSignalDiscoveryCostGuardrail(data.cost_guardrail),
+    warnings: Array.isArray(data.warnings) ? data.warnings.filter((warning) => typeof warning === "string") : void 0,
+    raw: data
+  };
+}
+function normalizeSignalDiscoveryCostGuardrail(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const guardrail = value;
+  const maxCost = Number(guardrail.max_cost_per_qualified_signal_usd);
+  const withinLimit = guardrail.within_limit === true;
+  if (!Number.isFinite(maxCost)) return void 0;
+  const numberOrNullable = (candidate) => {
+    if (candidate === null) return null;
+    const numeric = Number(candidate);
+    return Number.isFinite(numeric) ? numeric : void 0;
+  };
+  const numberOrUndefined = (candidate) => {
+    const numeric = Number(candidate);
+    return Number.isFinite(numeric) ? numeric : void 0;
+  };
+  return {
+    maxCostPerQualifiedSignalUsd: maxCost,
+    projectedSourceCostUsd: numberOrNullable(guardrail.projected_source_cost_usd),
+    maxSourceCostUsd: numberOrNullable(guardrail.max_source_cost_usd),
+    projectedCostPerRequestedCompanySignalUsd: numberOrNullable(
+      guardrail.projected_cost_per_requested_company_signal_usd
+    ),
+    sourceCostUsd: numberOrNullable(guardrail.source_cost_usd),
+    costSource: ["observed", "catalog_bounded", "mixed", "unavailable"].includes(String(guardrail.cost_source)) ? String(guardrail.cost_source) : void 0,
+    qualifiedCompanySignalCount: numberOrUndefined(guardrail.qualified_company_signal_count),
+    returnedCompanySignalCount: numberOrUndefined(guardrail.returned_company_signal_count),
+    costPerQualifiedSignalUsd: numberOrNullable(guardrail.cost_per_qualified_signal_usd),
+    withinLimit
+  };
+}
+function normalizeSignalDiscoverySignal(value) {
+  const signal = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const company = signal.company && typeof signal.company === "object" && !Array.isArray(signal.company) ? signal.company : {};
+  const companyName = String(company.name ?? signal.company_name ?? "").trim();
+  const companyDomain = String(company.domain ?? signal.company_domain ?? "").trim();
+  if (!companyName || !companyDomain) {
+    throw new Error("Signals Everything response violated the company attribution contract.");
+  }
+  return {
+    id: signal.id,
+    company: {
+      name: companyName,
+      domain: companyDomain,
+      linkedinUrl: company.linkedin_url ?? signal.company_linkedin_url ?? void 0
+    },
+    title: signal.title ?? "",
+    type: signal.type ?? signal.signal_type ?? "unknown",
+    summary: signal.summary ?? signal.content ?? signal.description ?? "",
+    eventDate: signal.event_date ?? signal.date ?? signal.signal_date ?? null,
+    evidence: Array.isArray(signal.evidence) ? signal.evidence.map((item) => ({
+      url: String(item?.url ?? ""),
+      publishedAt: String(item?.published_at ?? item?.publishedAt ?? ""),
+      source: String(item?.source ?? "")
+    })).filter((item) => Boolean(item.url)) : [],
+    content: signal.summary ?? signal.content ?? signal.description ?? "",
+    date: signal.event_date ?? signal.date ?? signal.signal_date ?? null,
+    detectedAt: signal.event_date ?? signal.detected_at ?? null,
+    sourceUrl: signal.source_url ?? signal.url ?? null,
+    sourceType: signal.source_type ?? null,
+    confidence: signal.confidence ?? signal.confidence_score ?? null,
+    classification: signal.signal_classification ?? signal.classification ?? null,
+    raw: signal
+  };
+}
 function validateBatchSize(items) {
   if (!Array.isArray(items) || items.length === 0) {
     throw new Error("Signaliz batch requests require at least one item");
@@ -1079,9 +1175,9 @@ function validatedBatchConcurrency(options) {
   }
   return concurrency;
 }
-function batchConcurrencyPlan(options) {
-  const concurrency = validatedBatchConcurrency(options);
-  const serverConcurrency = Math.min(10, concurrency);
+function batchConcurrencyPlan(options, defaultConcurrency = 10, maximumServerConcurrency = 10) {
+  const concurrency = options?.concurrency === void 0 ? defaultConcurrency : validatedBatchConcurrency(options);
+  const serverConcurrency = Math.min(maximumServerConcurrency, concurrency);
   return {
     serverConcurrency,
     chunkConcurrency: Math.max(1, Math.floor(concurrency / serverConcurrency))

package/dist/index.d.mts

@@ -169,6 +169,8 @@ interface CompanySignalEnrichmentParams {
     enableOutreachIntelligence?: boolean;
     enablePredictiveIntelligence?: boolean;
     skipCache?: boolean;
+    /** Include all evaluated evidence candidates, including rejected diagnostics. Defaults to selected-signal evidence only. */
+    includeCandidateEvidence?: boolean;
     /** @deprecated Company Signals is always synchronous; this option is ignored. */
     waitForResult?: boolean;
     /** Maximum server-side synchronous execution window. */
@@ -188,20 +190,13 @@ interface CompanySignal {
     date?: string | null;
     detectedAt?: string | null;
     datePrecision?: string;
-    hasSpecificDate?: boolean;
     sourceUrl?: string | null;
     sourceType?: string;
-    sourceProvenance?: string;
     confidence?: number | null;
-    entityConfidence?: number | null;
     signalFamily?: string;
     eventType?: string;
     eventLabel?: string;
     classification?: Record<string, unknown> | string | null;
-    derived?: boolean;
-    evidencePublishedDate?: string | null;
-    signalFeedSource?: string;
-    metadata?: Record<string, unknown>;
 }
 interface CompanySignalEnrichmentResult {
     success: boolean;
@@ -214,22 +209,89 @@ interface CompanySignalEnrichmentResult {
     signals: CompanySignal[];
     signalCount: number;
     signalSummary: string | null;
-    signalSummarySource?: string;
     intelligence?: Record<string, unknown> | null;
     copyFuel?: Record<string, unknown> | null;
     evidenceValidation?: Record<string, unknown>;
     evidenceSources?: Record<string, unknown>[];
-    credits?: Record<string, unknown>;
-    creditsUsed?: number;
-    costUsd?: number;
-    billingMetadata?: Record<string, unknown>;
-    resultReturnedFrom?: string;
-    cacheHit?: boolean;
-    freshEnrichmentUsed?: boolean;
-    liveProviderCalled?: boolean;
-    aiProviderCalled?: boolean;
-    byoAiUsed?: boolean;
-    metadata?: Record<string, unknown>;
+    evidenceCount?: number;
+    evidenceCountTotal?: number;
+    evidenceSourcesOmitted?: number;
+    evidenceScope?: 'selected_signals' | 'all_candidates';
+    raw: Record<string, unknown>;
+}
+type SignalDiscoverySource = 'web' | 'news';
+type SignalDiscoveryStatus = 'planned' | 'queued' | 'processing' | 'completed' | 'completed_with_warnings' | 'failed';
+interface SignalDiscoveryParams {
+    /** Natural-language description of the signals to find. Required for a new search. */
+    query?: string;
+    /** Number of qualified company signals requested. Defaults to 100; allowed range is 1-1,000. */
+    limit?: number;
+    /** Restrict discovery to selected source families. */
+    sources?: SignalDiscoverySource[];
+    /** Maximum signal age in days. Allowed range is 1-365. */
+    lookbackDays?: number;
+    /** Resume an existing asynchronous discovery run without starting another search. */
+    signalSearchRunId?: string;
+    /** Stable retry key for recovering the same search after an ambiguous response. */
+    idempotencyKey?: string;
+    /** Return a no-dispatch plan without provider calls or jobs. */
+    dryRun?: boolean;
+}
+interface SignalDiscoverySignal {
+    id?: string;
+    company: {
+        /** Every returned discovery signal is attributed to a distinct company. */
+        name: string;
+        domain: string;
+        linkedinUrl?: string | null;
+    };
+    title: string;
+    type: string;
+    summary: string;
+    eventDate?: string | null;
+    evidence: Array<{
+        url: string;
+        publishedAt: string;
+        source: string;
+    }>;
+    /** Compatibility alias for summary. */
+    content: string;
+    /** Compatibility alias for eventDate. */
+    date?: string | null;
+    detectedAt?: string | null;
+    sourceUrl?: string | null;
+    sourceType?: string | null;
+    confidence?: number | null;
+    classification?: Record<string, unknown> | string | null;
+    raw: Record<string, unknown>;
+}
+interface SignalDiscoveryCostGuardrail {
+    /** Strict ceiling: a qualified company signal must cost less than this amount to return. */
+    maxCostPerQualifiedSignalUsd: number;
+    projectedSourceCostUsd?: number | null;
+    maxSourceCostUsd?: number | null;
+    projectedCostPerRequestedCompanySignalUsd?: number | null;
+    sourceCostUsd?: number | null;
+    costSource?: 'observed' | 'catalog_bounded' | 'mixed' | 'unavailable';
+    qualifiedCompanySignalCount?: number;
+    returnedCompanySignalCount?: number;
+    costPerQualifiedSignalUsd?: number | null;
+    withinLimit: boolean;
+}
+interface SignalDiscoveryResult {
+    success: boolean;
+    status: SignalDiscoveryStatus;
+    capability: 'signals_everything';
+    signalSearchRunId: string;
+    query: string;
+    requestedCount: number;
+    nextPollAfterSeconds?: number;
+    signals: SignalDiscoverySignal[];
+    signalCount: number;
+    sourceLanes?: string[];
+    evidenceValidation?: Record<string, unknown>;
+    costGuardrail?: SignalDiscoveryCostGuardrail;
+    warnings?: string[];
     raw: Record<string, unknown>;
 }
 interface SignalToCopyParams {
@@ -323,6 +385,7 @@ declare class Signaliz {
         dryRun: true;
     }): Promise<CoreProductDryRunResult>;
     enrichCompanySignals(params: CompanySignalEnrichmentParams): Promise<CompanySignalEnrichmentResult>;
+    discoverSignals(params: SignalDiscoveryParams): Promise<SignalDiscoveryResult>;
     enrichCompanies(companies: CompanySignalEnrichmentParams[], options: BatchOptions & {
         dryRun: true;
     }): Promise<CoreProductDryRunResult>;
@@ -338,11 +401,10 @@ declare class Signaliz {
     private runCoreProductDryRun;
     private runSignalCopyBatchChunks;
     private runRecoverableCoreBatchJob;
-    private runRecoverableSignalCopyBatch;
     private runSignalCopyBatchChunk;
     private runCoreBatchRound;
     listTools(): Promise<MCPToolInfo[]>;
     health(): Promise<PlatformHealth>;
 }
 
-export { type BatchItemResult, type BatchOptions, type BatchResult, type CompanySignal, type CompanySignalEnrichmentParams, type CompanySignalEnrichmentResult, type ErrorType, type FindEmailParams, type FindEmailResult, type MCPToolInfo, type PlatformHealth, type SignalToCopyParams, type SignalToCopyResult, type SignalToCopyVariation, Signaliz, type SignalizConfig, SignalizError, type SignalizErrorData, type VerifyEmailBatchOptions, type VerifyEmailOptions, type VerifyEmailResult };
+export { type BatchItemResult, type BatchOptions, type BatchResult, type CompanySignal, type CompanySignalEnrichmentParams, type CompanySignalEnrichmentResult, type ErrorType, type FindEmailParams, type FindEmailResult, type MCPToolInfo, type PlatformHealth, type SignalDiscoveryParams, type SignalDiscoveryResult, type SignalDiscoverySignal, type SignalDiscoverySource, type SignalDiscoveryStatus, type SignalToCopyParams, type SignalToCopyResult, type SignalToCopyVariation, Signaliz, type SignalizConfig, SignalizError, type SignalizErrorData, type VerifyEmailBatchOptions, type VerifyEmailOptions, type VerifyEmailResult };