gloomberb 0.13.2 → 0.14.0

package/src/api-client/normalizers.ts

@@ -8,6 +8,7 @@ import type {
   CloudSearchResponse,
   CloudTweetPayload,
   CloudTweetSearchResponse,
+  TeamNotification,
 } from "./types";
 import { normalizeTimestamp } from "../utils/timestamp";
 
@@ -16,18 +17,25 @@ import { normalizeTimestamp } from "../utils/timestamp";
  * Both shapes are accepted so a server-side envelope change cannot silently
  * hand the pane an object with no `id`.
  */
-export function normalizeSavedSearchResponse(response: unknown): CloudSavedSearch {
-  const envelope = response as { search?: CloudSavedSearch } | CloudSavedSearch | null;
-  const search = envelope && "search" in envelope && envelope.search
-    ? envelope.search
-    : envelope as CloudSavedSearch | null;
-  if (!search?.id) throw new Error("The saved search response was missing a record.");
+export function normalizeSavedSearchResponse(
+  response: unknown,
+): CloudSavedSearch {
+  const envelope = response as
+    { search?: CloudSavedSearch } | CloudSavedSearch | null;
+  const search =
+    envelope && "search" in envelope && envelope.search
+      ? envelope.search
+      : (envelope as CloudSavedSearch | null);
+  if (!search?.id)
+    throw new Error("The saved search response was missing a record.");
   return search;
 }
 
 export function normalizeSavedSearchHits(response: unknown): CloudSearchHit[] {
   const hits = (response as { hits?: unknown } | null)?.hits;
-  return Array.isArray(hits) ? (hits as CloudSearchHit[]).map(normalizeSearchHit) : [];
+  return Array.isArray(hits)
+    ? (hits as CloudSearchHit[]).map(normalizeSearchHit)
+    : [];
 }
 
 /**
@@ -41,7 +49,9 @@ export function normalizeSearchHit(hit: CloudSearchHit): CloudSearchHit {
   return hit.ticker ? hit : { ...hit, ticker: "" };
 }
 
-export function normalizeSearchResponse(response: CloudSearchResponse): CloudSearchResponse {
+export function normalizeSearchResponse(
+  response: CloudSearchResponse,
+): CloudSearchResponse {
   const hits = response.hits;
   if (!Array.isArray(hits)) return { ...response, hits: [] };
   return { ...response, hits: hits.map(normalizeSearchHit) };
@@ -51,7 +61,9 @@ export function normalizeChatMessage(message: ChatMessage): ChatMessage {
   return {
     ...message,
     createdAt: normalizeTimestamp(message.createdAt),
-    ...(message.editedAt ? { editedAt: normalizeTimestamp(message.editedAt) } : {}),
+    ...(message.editedAt
+      ? { editedAt: normalizeTimestamp(message.editedAt) }
+      : {}),
   };
 }
 
@@ -59,7 +71,9 @@ export function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
   return messages.map((message) => normalizeChatMessage(message));
 }
 
-export function normalizeChatNotification(notification: ChatNotification): ChatNotification {
+export function normalizeChatNotification(
+  notification: ChatNotification,
+): ChatNotification {
   return {
     ...notification,
     createdAt: normalizeTimestamp(notification.createdAt),
@@ -67,7 +81,10 @@ export function normalizeChatNotification(notification: ChatNotification): ChatN
   };
 }
 
-export function normalizeChatChannel(channel: ChatChannel, fallbackKind: ChatChannel["kind"] = "public"): ChatChannel {
+export function normalizeChatChannel(
+  channel: ChatChannel,
+  fallbackKind: ChatChannel["kind"] = "public",
+): ChatChannel {
   return {
     ...channel,
     kind: channel.kind ?? fallbackKind,
@@ -75,7 +92,9 @@ export function normalizeChatChannel(channel: ChatChannel, fallbackKind: ChatCha
   };
 }
 
-export function normalizeChatState(response: ChatStateResponse): ChatStateResponse {
+export function normalizeChatState(
+  response: ChatStateResponse,
+): ChatStateResponse {
   return {
     ...response,
     channels: response.channels.map((channel) => normalizeChatChannel(channel)),
@@ -83,6 +102,15 @@ export function normalizeChatState(response: ChatStateResponse): ChatStateRespon
   };
 }
 
+export function normalizeTeamNotification(
+  notification: TeamNotification,
+): TeamNotification {
+  return {
+    ...notification,
+    createdAt: normalizeTimestamp(notification.createdAt),
+  };
+}
+
 function normalizeTweet(tweet: CloudTweetPayload): CloudTweetPayload {
   return {
     ...tweet,
@@ -90,7 +118,9 @@ function normalizeTweet(tweet: CloudTweetPayload): CloudTweetPayload {
   };
 }
 
-export function normalizeTweetSearchResponse(response: CloudTweetSearchResponse): CloudTweetSearchResponse {
+export function normalizeTweetSearchResponse(
+  response: CloudTweetSearchResponse,
+): CloudTweetSearchResponse {
   return {
     ...response,
     since: normalizeTimestamp(response.since),

package/src/api-client/notes.ts

@@ -0,0 +1,89 @@
+import { ApiRequestError } from "./errors";
+import type { CloudNote, CloudNoteScope, CloudNoteSummary, NoteKind } from "./types";
+
+type CloudApiRequest = <T>(path: string, options?: RequestInit) => Promise<T>;
+
+/** A save refused because the note changed since it was loaded. */
+export class NoteConflictError extends Error {
+  constructor(
+    message: string,
+    public readonly current: CloudNote | null,
+  ) {
+    super(message);
+    this.name = "NoteConflictError";
+  }
+}
+
+function scopeQuery(scope: CloudNoteScope): string {
+  const params = new URLSearchParams({ scope: scope.scope });
+  if (scope.teamId) params.set("teamId", scope.teamId);
+  return params.toString();
+}
+
+export class CloudNotesApi {
+  constructor(private readonly request: CloudApiRequest) {}
+
+  async listNotes(scope: CloudNoteScope): Promise<CloudNoteSummary[]> {
+    const body = await this.request<{ items: CloudNoteSummary[] }>(`/notes?${scopeQuery(scope)}`);
+    return body.items;
+  }
+
+  async getNote(id: string): Promise<CloudNote | null> {
+    try {
+      return await this.request<CloudNote>(`/notes/${encodeURIComponent(id)}`);
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 404) return null;
+      throw error;
+    }
+  }
+
+  /**
+   * Upserts by (owner, kind, key). `expectedRevision` becomes If-Match; a 412
+   * throws NoteConflictError carrying the note the server holds now.
+   */
+  async putNote(input: {
+    scope: CloudNoteScope;
+    kind: NoteKind;
+    key: string;
+    title?: string | null;
+    content: string;
+    expectedRevision?: number;
+  }): Promise<CloudNote> {
+    try {
+      return await this.request<CloudNote>("/notes", {
+        method: "PUT",
+        headers: input.expectedRevision ? { "if-match": String(input.expectedRevision) } : {},
+        body: JSON.stringify({
+          scope: input.scope.scope,
+          ...(input.scope.teamId ? { teamId: input.scope.teamId } : {}),
+          kind: input.kind,
+          key: input.key,
+          ...(input.title !== undefined ? { title: input.title } : {}),
+          content: input.content,
+        }),
+      });
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 412) {
+        // The 412 body carries the current note, but the transport keeps only
+        // the message. One extra read gets the editor's name and content.
+        const current = await this.findNote(input.scope, input.kind, input.key).catch(() => null);
+        throw new NoteConflictError(error.message, current);
+      }
+      throw error;
+    }
+  }
+
+  async deleteNote(id: string): Promise<void> {
+    try {
+      await this.request<unknown>(`/notes/${encodeURIComponent(id)}`, { method: "DELETE" });
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 404) return;
+      throw error;
+    }
+  }
+
+  private async findNote(scope: CloudNoteScope, kind: NoteKind, key: string): Promise<CloudNote | null> {
+    const summary = (await this.listNotes(scope)).find((entry) => entry.kind === kind && entry.key === key);
+    return summary ? this.getNote(summary.id) : null;
+  }
+}

package/src/api-client/paths.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from "bun:test";
+import {
+  cloudEarningsCallsPath, cloudSecFilingsPath, normalizeIssuerResearchTicker,
+  publicFilingEventsPath, publicProxyStatementPath, publicProxyStatementsPath,
+  publicRiskReportPath, publicRiskReportsPath,
+} from "./paths";
+
+test("issuer research paths accept explicit US listing aliases without changing issuer symbol content", () => {
+  for (const [key, issuer] of [
+    [" aapl:XNAS ", "AAPL"], ["MSFT:NASDAQ", "MSFT"], ["BRK.B:XNYS", "BRK.B"],
+    ["SPY:PCX", "SPY"], ["SPY:ARCX", "SPY"], ["IWM:AMEX", "IWM"], ["TEST:BATS", "TEST"],
+    ["AAPL:NASDAQ:XNAS", "AAPL"], ["BABA:XNYS", "BABA"], ["VOD.L:XNAS", "VOD.L"],
+  ]) {
+    const encoded = encodeURIComponent(issuer!);
+    expect(publicProxyStatementsPath(key!)).toBe(`/public/proxies/${encoded}`);
+    expect(publicProxyStatementPath(key!, 2026)).toBe(`/public/proxies/${encoded}/2026`);
+    expect(publicRiskReportsPath(key!)).toBe(`/public/risks/${encoded}`);
+    expect(publicRiskReportPath(key!, 2025)).toBe(`/public/risks/${encoded}/2025`);
+    expect(publicFilingEventsPath(key!, 7)).toBe(`/public/events/${encoded}?limit=7`);
+    expect(cloudEarningsCallsPath({ ticker: key!, limit: 3, offset: 2 })).toBe(`/cloud/transcripts?ticker=${encoded}&limit=3&offset=2`);
+    expect(cloudSecFilingsPath({ ticker: key!, limit: 5 })).toBe(`/cloud/sec/filings?ticker=${encoded}&limit=5`);
+  }
+});
+
+test("issuer research never infers a US issuer from foreign, unknown or routing venues", () => {
+  for (const key of ["SHOP:XTSE", "ASML:XAMS", "7203:JPX", "BABA:XHKG", "VOD.L", "VOD.L:XLON", "SAP.DE", "AAPL:SMART", "AAPL:UNKNOWN", "AAPL:US", "AAPL", "BRK.B"]) {
+    expect(normalizeIssuerResearchTicker(key)).toBe(key);
+    expect(publicProxyStatementsPath(key)).toBe(`/public/proxies/${encodeURIComponent(key)}`);
+    expect(new URL(cloudSecFilingsPath({ ticker: key }), "https://example.test").searchParams.get("ticker")).toBe(key);
+    expect(new URL(cloudEarningsCallsPath({ ticker: key }), "https://example.test").searchParams.get("ticker")).toBe(key);
+  }
+});

package/src/api-client/paths.ts

@@ -1,5 +1,9 @@
-import type { CloudSearchDocType, CloudSearchSort, CloudTweetQueryType } from "./types";
-import { normalizeSymbol, publicTickerKey } from "../utils/exchanges";
+import type {
+  CloudSearchDocType,
+  CloudSearchSort,
+  CloudTweetQueryType,
+} from "./types";
+import { normalizeSymbol, parsePublicTickerKey, publicTickerKey } from "../utils/exchanges";
 
 export type CloudHistoryParams = {
   interval?: string;
@@ -66,6 +70,7 @@ export type CloudNewsParams = {
 export type CloudTickerTweetsParams = {
   ticker: string;
   limit?: number;
+  offset?: number;
   hours?: number;
   includeReplies?: boolean;
 };
@@ -74,6 +79,7 @@ export type CloudTweetSearchParams = {
   query: string;
   queryType?: CloudTweetQueryType;
   limit?: number;
+  offset?: number;
   hours?: number;
 };
 
@@ -82,13 +88,19 @@ const CRYPTO_QUOTE = /[-/](USD|USDT|USDC|EUR|GBP|BTC)$/;
 
 export type CloudLogoKind = "ticker" | "crypto";
 
-export function normalizeCloudLogoSymbol(kind: CloudLogoKind, symbol: string): string | null {
+export function normalizeCloudLogoSymbol(
+  kind: CloudLogoKind,
+  symbol: string,
+): string | null {
   let normalized = symbol.trim().toUpperCase();
   if (kind === "crypto") normalized = normalized.replace(CRYPTO_QUOTE, "");
   return LOGO_SYMBOL_RE.test(normalized) ? normalized : null;
 }
 
-export function cloudLogoPath(kind: CloudLogoKind, symbol: string): string | null {
+export function cloudLogoPath(
+  kind: CloudLogoKind,
+  symbol: string,
+): string | null {
   const normalized = normalizeCloudLogoSymbol(kind, symbol);
   if (!normalized) return null;
   return `/cloud/logos/${kind}/${encodeURIComponent(normalized)}`;
@@ -100,22 +112,34 @@ function appendQuery(path: string, search: URLSearchParams): string {
 }
 
 export function cloudMarketSearchPath(query: string, limit: number): string {
-  return appendQuery("/market/search", new URLSearchParams({
-    q: query,
-    limit: String(limit),
-  }));
+  return appendQuery(
+    "/market/search",
+    new URLSearchParams({
+      q: query,
+      limit: String(limit),
+    }),
+  );
 }
 
-export function cloudMarketSymbolPath(path: string, symbol: string, exchange?: string): string {
+export function cloudMarketSymbolPath(
+  path: string,
+  symbol: string,
+  exchange?: string,
+): string {
   const search = new URLSearchParams({ symbol });
   if (exchange) search.set("exchange", exchange);
   return appendQuery(path, search);
 }
 
-export function cloudOptionsChainPath(symbol: string, exchange?: string, expirationDate?: number): string {
+export function cloudOptionsChainPath(
+  symbol: string,
+  exchange?: string,
+  expirationDate?: number,
+): string {
   const search = new URLSearchParams({ symbol });
   if (exchange) search.set("exchange", exchange);
-  if (expirationDate != null) search.set("expirationDate", String(expirationDate));
+  if (expirationDate != null)
+    search.set("expirationDate", String(expirationDate));
   return appendQuery("/market/options", search);
 }
 
@@ -129,10 +153,15 @@ export function cloudStatementsPath(
   return appendQuery("/market/statements", search);
 }
 
-export function cloudHistoryPath(symbol: string, exchange: string, params: CloudHistoryParams = {}): string {
+export function cloudHistoryPath(
+  symbol: string,
+  exchange: string,
+  params: CloudHistoryParams = {},
+): string {
   const search = new URLSearchParams({ symbol, exchange });
   if (params.interval) search.set("interval", params.interval);
-  if (params.outputsize != null) search.set("outputsize", String(params.outputsize));
+  if (params.outputsize != null)
+    search.set("outputsize", String(params.outputsize));
   if (params.startDate) search.set("startDate", params.startDate);
   if (params.endDate) search.set("endDate", params.endDate);
   if (params.rangeKey) search.set("rangeKey", params.rangeKey);
@@ -144,16 +173,25 @@ export function cloudShillerPath(): string {
 }
 
 export function cloudExchangeRatePath(fromCurrency: string): string {
-  return appendQuery("/market/exchange-rate", new URLSearchParams({ fromCurrency }));
+  return appendQuery(
+    "/market/exchange-rate",
+    new URLSearchParams({ fromCurrency }),
+  );
 }
 
-export function cloudFredSeriesPath(seriesId: string, params: CloudFredSeriesParams = {}): string {
+export function cloudFredSeriesPath(
+  seriesId: string,
+  params: CloudFredSeriesParams = {},
+): string {
   const search = new URLSearchParams();
   if (params.startDate) search.set("startDate", params.startDate);
   if (params.endDate) search.set("endDate", params.endDate);
   if (params.limit != null) search.set("limit", String(params.limit));
   if (params.sortOrder) search.set("sortOrder", params.sortOrder);
-  return appendQuery(`/cloud/econ/series/${encodeURIComponent(seriesId)}`, search);
+  return appendQuery(
+    `/cloud/econ/series/${encodeURIComponent(seriesId)}`,
+    search,
+  );
 }
 
 export function cloudCdsPath(params: CloudCdsParams = {}): string {
@@ -180,22 +218,68 @@ export type CloudSecFilingParams = {
   filingUrl?: string;
 };
 
-export function cloudCongressHousePath(params: CloudCongressHouseParams = {}): string {
+export function cloudCongressHousePath(
+  params: CloudCongressHouseParams = {},
+): string {
   const search = new URLSearchParams();
   if (params.year != null) search.set("year", String(params.year));
   if (params.limit != null) search.set("limit", String(params.limit));
   if (params.offset != null) search.set("offset", String(params.offset));
-  if (params.filingLimit != null) search.set("filingLimit", String(params.filingLimit));
-  if (params.filingOffset != null) search.set("filingOffset", String(params.filingOffset));
+  if (params.filingLimit != null)
+    search.set("filingLimit", String(params.filingLimit));
+  if (params.filingOffset != null)
+    search.set("filingOffset", String(params.filingOffset));
   if (params.member) search.set("member", params.member);
   if (params.ticker) search.set("ticker", params.ticker);
   if (params.refresh != null) search.set("refresh", String(params.refresh));
   return appendQuery("/cloud/congress/house", search);
 }
 
-export function cloudEarningsCallsPath(params: CloudEarningsCallsParams = {}): string {
+const US_ISSUER_LISTINGS = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "BATS"]);
+
+/** Issuer endpoints accept US ticker symbols, not the pane's listing key. */
+export function normalizeIssuerResearchTicker(ticker: string): string {
+  const parsed = parsePublicTickerKey(ticker);
+  return parsed.exchange && US_ISSUER_LISTINGS.has(parsed.exchange)
+    ? parsed.symbol : normalizeSymbol(ticker);
+}
+
+export function cloudJobsPath(ticker: string, name?: string | null): string {
   const search = new URLSearchParams();
-  if (params.ticker) search.set("ticker", params.ticker);
+  if (name) search.set("name", name);
+  return appendQuery(`/cloud/jobs/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}`, search);
+}
+
+export interface CloudJobsPostingsParams {
+  function?: string;
+  q?: string;
+  limit?: number;
+  offset?: number;
+  includeClosed?: boolean;
+}
+
+export function cloudJobsPostingsPath(ticker: string, params: CloudJobsPostingsParams = {}): string {
+  const search = new URLSearchParams();
+  if (params.function) search.set("function", params.function);
+  if (params.q) search.set("q", params.q);
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset != null) search.set("offset", String(params.offset));
+  if (params.includeClosed) search.set("includeClosed", "true");
+  return appendQuery(`/cloud/jobs/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}/postings`, search);
+}
+
+export function cloudJobsMoversPath(limit?: number, offset?: number): string {
+  const search = new URLSearchParams();
+  if (limit != null) search.set("limit", String(limit));
+  if (offset) search.set("offset", String(offset));
+  return appendQuery("/cloud/jobs", search);
+}
+
+export function cloudEarningsCallsPath(
+  params: CloudEarningsCallsParams = {},
+): string {
+  const search = new URLSearchParams();
+  if (params.ticker) search.set("ticker", normalizeIssuerResearchTicker(params.ticker));
   if (params.limit != null) search.set("limit", String(params.limit));
   if (params.offset != null) search.set("offset", String(params.offset));
   if (params.includePending) search.set("includePending", "true");
@@ -206,35 +290,71 @@ export function cloudEarningsTranscriptPath(id: string): string {
   return `/cloud/transcripts/${encodeURIComponent(id)}`;
 }
 
+/** Executive compensation reads are open: no account, no plan. */
+export function publicProxyStatementsPath(ticker: string): string {
+  return `/public/proxies/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}`;
+}
+
+export function publicFilingEventsPath(ticker: string, limit?: number): string {
+  const search = new URLSearchParams();
+  if (limit != null) search.set("limit", String(limit));
+  return appendQuery(
+    `/public/events/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}`,
+    search,
+  );
+}
+
+export function publicRiskReportsPath(ticker: string): string {
+  return `/public/risks/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}`;
+}
+
+export function publicRiskReportPath(ticker: string, year: number): string {
+  return `/public/risks/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}/${year}`;
+}
+
+export function publicProxyStatementPath(ticker: string, year: number): string {
+  return `/public/proxies/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}/${year}`;
+}
+
 export function cloudSecFilingsPath(params: CloudSecFilingsParams): string {
-  const search = new URLSearchParams({ ticker: params.ticker });
+  const search = new URLSearchParams({ ticker: normalizeIssuerResearchTicker(params.ticker) });
   if (params.limit != null) search.set("limit", String(params.limit));
   if (params.offset != null) search.set("offset", String(params.offset));
   return appendQuery("/cloud/sec/filings", search);
 }
 
-export function cloudSecFilingDocumentsPath(params: CloudSecFilingParams): string {
+export function cloudSecFilingDocumentsPath(
+  params: CloudSecFilingParams,
+): string {
   const search = new URLSearchParams();
   if (params.cik) search.set("cik", params.cik);
   if (params.accession) search.set("accession", params.accession);
   if (params.form) search.set("form", params.form);
-  if (params.primaryDocument) search.set("primaryDocument", params.primaryDocument);
+  if (params.primaryDocument)
+    search.set("primaryDocument", params.primaryDocument);
   if (params.filingUrl) search.set("filingUrl", params.filingUrl);
   return appendQuery("/cloud/sec/filing/documents", search);
 }
 
-export function cloudSecFilingContentPath(params: CloudSecFilingParams): string {
+export function cloudSecFilingContentPath(
+  params: CloudSecFilingParams,
+): string {
   const search = new URLSearchParams();
   if (params.cik) search.set("cik", params.cik);
   if (params.accession) search.set("accession", params.accession);
   if (params.form) search.set("form", params.form);
-  if (params.primaryDocument) search.set("primaryDocument", params.primaryDocument);
-  if (params.primaryDocumentUrl) search.set("primaryDocumentUrl", params.primaryDocumentUrl);
+  if (params.primaryDocument)
+    search.set("primaryDocument", params.primaryDocument);
+  if (params.primaryDocumentUrl)
+    search.set("primaryDocumentUrl", params.primaryDocumentUrl);
   if (params.filingUrl) search.set("filingUrl", params.filingUrl);
   return appendQuery("/cloud/sec/filing/content", search);
 }
 
-export function cloudSec13FPath(path: string, params: Record<string, string | number | undefined> = {}): string {
+export function cloudSec13FPath(
+  path: string,
+  params: Record<string, string | number | undefined> = {},
+): string {
   const search = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
     if (value !== undefined) search.set(key, String(value));
@@ -262,7 +382,9 @@ export type CloudSearchParams = {
 
 function csvParam(values: readonly string[] | undefined): string | null {
   if (!values) return null;
-  const cleaned = values.map((value) => value.trim()).filter((value) => value.length > 0);
+  const cleaned = values
+    .map((value) => value.trim())
+    .filter((value) => value.length > 0);
   return cleaned.length > 0 ? cleaned.join(",") : null;
 }
 
@@ -286,7 +408,10 @@ export function cloudSearchPath(params: CloudSearchParams): string {
   return appendQuery("/cloud/search", search);
 }
 
-export function cloudSearchDocumentPath(docType: CloudSearchDocType, sourceId: string): string {
+export function cloudSearchDocumentPath(
+  docType: CloudSearchDocType,
+  sourceId: string,
+): string {
   return `/cloud/search/documents/${encodeURIComponent(docType)}/${encodeURIComponent(sourceId)}`;
 }
 
@@ -312,16 +437,21 @@ export function cloudNewsPath(params: CloudNewsParams = {}): string {
     search.set("tickers", tickerFilter);
   }
   if (params.tickerTier) search.set("tickerTier", params.tickerTier);
-  if (params.tickerRelations?.length) search.set("tickerRelations", params.tickerRelations.join(","));
+  if (params.tickerRelations?.length)
+    search.set("tickerRelations", params.tickerRelations.join(","));
   if (params.limit != null) search.set("limit", String(params.limit));
   if (params.topics?.length) search.set("topics", params.topics.join(","));
-  if (params.categories?.length) search.set("categories", params.categories.join(","));
+  if (params.categories?.length)
+    search.set("categories", params.categories.join(","));
   if (params.sectors?.length) search.set("sectors", params.sectors.join(","));
   if (params.sources?.length) search.set("sources", params.sources.join(","));
-  if (params.excludeSources?.length) search.set("excludeSources", params.excludeSources.join(","));
+  if (params.excludeSources?.length)
+    search.set("excludeSources", params.excludeSources.join(","));
   if (params.sentiment) search.set("sentiment", params.sentiment);
-  if (params.minImportance != null) search.set("minImportance", String(params.minImportance));
-  if (params.minUrgency != null) search.set("minUrgency", String(params.minUrgency));
+  if (params.minImportance != null)
+    search.set("minImportance", String(params.minImportance));
+  if (params.minUrgency != null)
+    search.set("minUrgency", String(params.minUrgency));
   if (params.breaking != null) search.set("breaking", String(params.breaking));
   if (params.since) search.set("since", params.since.toISOString());
   if (params.until) search.set("until", params.until.toISOString());
@@ -332,8 +462,10 @@ export function cloudNewsPath(params: CloudNewsParams = {}): string {
 export function cloudTickerTweetsPath(params: CloudTickerTweetsParams): string {
   const search = new URLSearchParams({ ticker: params.ticker });
   if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset) search.set("offset", String(params.offset));
   if (params.hours != null) search.set("hours", String(params.hours));
-  if (params.includeReplies != null) search.set("includeReplies", String(params.includeReplies));
+  if (params.includeReplies != null)
+    search.set("includeReplies", String(params.includeReplies));
   return appendQuery("/news/tweets", search);
 }
 
@@ -341,6 +473,7 @@ export function cloudTweetSearchPath(params: CloudTweetSearchParams): string {
   const search = new URLSearchParams({ query: params.query });
   if (params.queryType) search.set("queryType", params.queryType);
   if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset) search.set("offset", String(params.offset));
   if (params.hours != null) search.set("hours", String(params.hours));
   return appendQuery("/news/tweets/search", search);
 }