linkedin-secret-sauce 0.3.29 → 0.4.0

package/dist/http-client.js

@@ -45,11 +45,30 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function isRetryableStatus(status) {
-    return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+    return (status === 429 ||
+        status === 500 ||
+        status === 502 ||
+        status === 503 ||
+        status === 504);
+}
+/**
+ * Redact sensitive parts of URL for safe logging.
+ * Preserves hostname and path but removes query parameters which may contain session info.
+ */
+function redactUrlForLogging(url) {
+    try {
+        const parsed = new URL(url);
+        // Keep only host and pathname, remove query params
+        return `${parsed.host}${parsed.pathname}`;
+    }
+    catch {
+        // If URL parsing fails, just return a safe placeholder
+        return "[invalid-url]";
+    }
 }
 async function executeLinkedInRequest(options, _operationName) {
     const config = (0, config_1.getConfig)();
-    const op = _operationName || 'request';
+    const op = _operationName || "request";
     const perAccountAttempts = (config.maxRetries ?? 0) + 1;
     const delay = config.retryDelayMs ?? 700;
     // Setup proxy env if configured
@@ -62,7 +81,7 @@ async function executeLinkedInRequest(options, _operationName) {
             process.env.HTTP_PROXY = proxyUrl;
             process.env.HTTPS_PROXY = proxyUrl;
             proxySet = true;
-            (0, logger_1.log)('info', 'proxy.set', { host: masked });
+            (0, logger_1.log)("info", "proxy.set", { host: masked });
         }
         // Phase 1.4: Try ALL available accounts (not just 3)
         const health = (0, cookie_pool_1.getCookiePoolHealth)();
@@ -77,8 +96,10 @@ async function executeLinkedInRequest(options, _operationName) {
             catch (err) {
                 const e = err;
                 // Phase 1.3: If NO_VALID_ACCOUNTS, try force refresh once
-                if (e?.code === 'NO_VALID_ACCOUNTS' && accountsTriedCount > 0) {
-                    (0, logger_1.log)('warn', 'http.noValidAccounts.forceRefresh', { accountsTriedCount });
+                if (e?.code === "NO_VALID_ACCOUNTS" && accountsTriedCount > 0) {
+                    (0, logger_1.log)("warn", "http.noValidAccounts.forceRefresh", {
+                        accountsTriedCount,
+                    });
                     try {
                         await (0, cookie_pool_1.forceRefreshCookies)();
                         // Retry selection after refresh
@@ -86,31 +107,43 @@ async function executeLinkedInRequest(options, _operationName) {
                     }
                     catch (refreshErr) {
                         const re = refreshErr;
-                        (0, logger_1.log)('error', 'http.forceRefreshFailed', { error: re?.message });
+                        (0, logger_1.log)("error", "http.forceRefreshFailed", { error: re?.message });
                         // Report to Sentry
                         try {
-                            const { reportCriticalError } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
-                            reportCriticalError('All accounts exhausted, force refresh failed', {
+                            const { reportCriticalError } = await Promise.resolve().then(() => __importStar(require("./utils/sentry")));
+                            reportCriticalError("All accounts exhausted, force refresh failed", {
                                 error: re?.message,
                                 accountsTriedCount,
-                                tags: { component: 'http-client', severity: 'critical' },
+                                tags: { component: "http-client", severity: "critical" },
                             });
                         }
                         catch { }
                     }
                 }
-                if (!selection && process.env.NODE_ENV !== 'test')
+                if (!selection && process.env.NODE_ENV !== "test")
                     throw err;
             }
             if (!selection || !selection.accountId) {
-                if (process.env.NODE_ENV === 'test') {
+                if (process.env.NODE_ENV === "test") {
                     const fallback = rotation === 0
-                        ? { accountId: 'acc1', cookies: [{ name: 'li_at', value: 'A' }, { name: 'JSESSIONID', value: '"csrf1"' }] }
-                        : { accountId: 'acc2', cookies: [{ name: 'li_at', value: 'B' }, { name: 'JSESSIONID', value: '"csrf2"' }] };
+                        ? {
+                            accountId: "acc1",
+                            cookies: [
+                                { name: "li_at", value: "A" },
+                                { name: "JSESSIONID", value: '"csrf1"' },
+                            ],
+                        }
+                        : {
+                            accountId: "acc2",
+                            cookies: [
+                                { name: "li_at", value: "B" },
+                                { name: "JSESSIONID", value: '"csrf2"' },
+                            ],
+                        };
                     selection = fallback;
                 }
                 else {
-                    throw new errors_1.LinkedInClientError('No LinkedIn accounts available', 'NO_ACCOUNTS', 503);
+                    throw new errors_1.LinkedInClientError("No LinkedIn accounts available", "NO_ACCOUNTS", 503);
                 }
             }
             const { accountId, cookies } = selection;
@@ -118,51 +151,79 @@ async function executeLinkedInRequest(options, _operationName) {
             const csrf = (0, cookie_pool_1.extractCsrfToken)(cookies);
             const cookieHeader = (0, cookie_pool_1.buildCookieHeader)(cookies);
             // Choose header profile based on Sales vs Voyager context
-            const isSales = /\/sales\//i.test(String(options.headers?.Referer || ''))
-                || /https:\/\/www\.linkedin\.com\/sales-api/i.test(options.url);
+            const isSales = /\/sales\//i.test(String(options.headers?.Referer || "")) ||
+                /https:\/\/www\.linkedin\.com\/sales-api/i.test(options.url);
             const baseHeaders = isSales
-                ? (0, linkedin_config_1.buildSalesHeaders)({ cookiesHeader: cookieHeader, csrf, referer: options.headers?.Referer })
-                : (0, linkedin_config_1.buildVoyagerHeaders)({ cookiesHeader: cookieHeader, csrf, referer: options.headers?.Referer });
+                ? (0, linkedin_config_1.buildSalesHeaders)({
+                    cookiesHeader: cookieHeader,
+                    csrf,
+                    referer: options.headers?.Referer,
+                })
+                : (0, linkedin_config_1.buildVoyagerHeaders)({
+                    cookiesHeader: cookieHeader,
+                    csrf,
+                    referer: options.headers?.Referer,
+                });
             const headers = {
                 ...baseHeaders,
                 ...(options.headers || {}),
             };
             for (let attempt = 0; attempt < perAccountAttempts; attempt++) {
                 const started = Date.now();
-                (0, logger_1.log)('debug', 'http.attempt', { accountId, attempt: attempt + 1, method: options.method ?? 'GET', url: options.url });
+                (0, logger_1.log)("debug", "http.attempt", {
+                    accountId,
+                    attempt: attempt + 1,
+                    method: options.method ?? "GET",
+                    url: redactUrlForLogging(options.url),
+                });
                 let res;
                 try {
                     const init = {
-                        method: options.method ?? 'GET',
+                        method: options.method ?? "GET",
                         headers,
                     };
                     if (options.body !== undefined) {
-                        init.body = typeof options.body === 'string' ? options.body : JSON.stringify(options.body);
+                        init.body =
+                            typeof options.body === "string"
+                                ? options.body
+                                : JSON.stringify(options.body);
                     }
                     res = (await fetch(options.url, init));
                 }
                 catch (err) {
                     const e = err;
-                    const code = e?.code || e?.cause?.code || 'FETCH_FAILED';
-                    (0, logger_1.log)('error', 'http.networkError', { accountId, url: options.url, code, message: String(e?.message || err) });
-                    (0, metrics_1.incrementMetric)('httpFailures');
+                    const code = e?.code || e?.cause?.code || "FETCH_FAILED";
+                    (0, logger_1.log)("error", "http.networkError", {
+                        accountId,
+                        url: redactUrlForLogging(options.url),
+                        code,
+                        message: String(e?.message || err),
+                    });
+                    (0, metrics_1.incrementMetric)("httpFailures");
                     try {
-                        (0, request_history_1.recordRequest)({ operation: op, selector: options.url, status: 0, durationMs: Date.now() - started, accountId, errorMessage: String(e?.message || err) });
+                        (0, request_history_1.recordRequest)({
+                            operation: op,
+                            selector: options.url,
+                            status: 0,
+                            durationMs: Date.now() - started,
+                            accountId,
+                            errorMessage: String(e?.message || err),
+                        });
                     }
                     catch { }
                     // Report network errors to Sentry
                     try {
-                        const { reportWarningToSentry } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
-                        reportWarningToSentry('Network error during LinkedIn request', {
+                        const { reportWarningToSentry } = await Promise.resolve().then(() => __importStar(require("./utils/sentry")));
+                        reportWarningToSentry("Network error during LinkedIn request", {
                             code,
-                            url: options.url,
+                            url: redactUrlForLogging(options.url),
                             accountId,
                             error: String(e?.message || err),
-                            tags: { component: 'http-client', severity: 'high' },
+                            tags: { component: "http-client", severity: "high" },
                         });
                     }
                     catch { }
-                    lastError = new errors_1.LinkedInClientError('LinkedIn fetch failed', 'REQUEST_FAILED', 0, accountId);
+                    lastError = new errors_1.LinkedInClientError("LinkedIn fetch failed", "REQUEST_FAILED", 0, accountId);
                     break; // rotate to next account
                 }
                 if (res.ok) {
@@ -171,8 +232,11 @@ async function executeLinkedInRequest(options, _operationName) {
                         (0, cookie_pool_1.reportAccountSuccess)(accountId);
                     }
                     catch { }
-                    (0, logger_1.log)('info', 'http.success', { accountId, url: options.url });
-                    (0, metrics_1.incrementMetric)('httpSuccess');
+                    (0, logger_1.log)("info", "http.success", {
+                        accountId,
+                        url: redactUrlForLogging(options.url),
+                    });
+                    (0, metrics_1.incrementMetric)("httpSuccess");
                     try {
                         (0, request_history_1.recordRequest)({
                             operation: op,
@@ -192,10 +256,10 @@ async function executeLinkedInRequest(options, _operationName) {
                         (0, cookie_pool_1.reportAccountFailure)(accountId, true);
                     }
                     catch { }
-                    (0, logger_1.log)('warn', 'http.rotateOnAuth', { accountId, status });
-                    (0, metrics_1.incrementMetric)('authErrors');
-                    (0, metrics_1.incrementMetric)('httpFailures');
-                    lastError = new errors_1.LinkedInClientError(`LinkedIn request failed: ${status}`, 'REQUEST_FAILED', status, accountId);
+                    (0, logger_1.log)("warn", "http.rotateOnAuth", { accountId, status });
+                    (0, metrics_1.incrementMetric)("authErrors");
+                    (0, metrics_1.incrementMetric)("httpFailures");
+                    lastError = new errors_1.LinkedInClientError(`LinkedIn request failed: ${status}`, "REQUEST_FAILED", status, accountId);
                     try {
                         (0, request_history_1.recordRequest)({
                             operation: op,
@@ -203,7 +267,7 @@ async function executeLinkedInRequest(options, _operationName) {
                             status,
                             durationMs: Date.now() - started,
                             accountId,
-                            errorMessage: 'rotate',
+                            errorMessage: "rotate",
                         });
                     }
                     catch { }
@@ -212,38 +276,54 @@ async function executeLinkedInRequest(options, _operationName) {
                 // Phase 1.5: Proxy fallback on 502/503/504 if enabled
                 const isProxyError = status === 502 || status === 503 || status === 504;
                 const fallbackEnabled = config.fallbackWithoutProxyOnError ?? false;
-                if (isProxyError && fallbackEnabled && proxySet && attempt < perAccountAttempts - 1) {
-                    (0, logger_1.log)('warn', 'http.proxyFallback', { accountId, status, attempt: attempt + 1 });
+                if (isProxyError &&
+                    fallbackEnabled &&
+                    proxySet &&
+                    attempt < perAccountAttempts - 1) {
+                    (0, logger_1.log)("warn", "http.proxyFallback", {
+                        accountId,
+                        status,
+                        attempt: attempt + 1,
+                    });
                     // Temporarily disable proxy for this retry
                     delete process.env.HTTP_PROXY;
                     delete process.env.HTTPS_PROXY;
                     proxySet = false;
                     // Report to Sentry
                     try {
-                        const { reportWarningToSentry } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
-                        reportWarningToSentry('Proxy error, retrying without proxy', {
+                        const { reportWarningToSentry } = await Promise.resolve().then(() => __importStar(require("./utils/sentry")));
+                        reportWarningToSentry("Proxy error, retrying without proxy", {
                             status,
-                            url: options.url,
+                            url: redactUrlForLogging(options.url),
                             accountId,
-                            tags: { component: 'http-client', severity: 'medium' },
+                            tags: { component: "http-client", severity: "medium" },
                         });
                     }
                     catch { }
-                    (0, metrics_1.incrementMetric)('httpRetries');
+                    (0, metrics_1.incrementMetric)("httpRetries");
                     await sleep(delay);
                     continue;
                 }
                 // Retryable 5xx on same account
-                if ((status >= 500 && status < 600) && attempt < perAccountAttempts - 1) {
-                    (0, logger_1.log)('debug', 'http.retry', { accountId, status, attempt: attempt + 1, nextDelayMs: delay });
-                    (0, metrics_1.incrementMetric)('httpRetries');
+                if (status >= 500 && status < 600 && attempt < perAccountAttempts - 1) {
+                    (0, logger_1.log)("debug", "http.retry", {
+                        accountId,
+                        status,
+                        attempt: attempt + 1,
+                        nextDelayMs: delay,
+                    });
+                    (0, metrics_1.incrementMetric)("httpRetries");
                     await sleep(delay);
                     continue;
                 }
                 // Non-retryable: throw
-                const err = new errors_1.LinkedInClientError(`LinkedIn request failed: ${status}`, 'REQUEST_FAILED', status, accountId);
-                (0, metrics_1.incrementMetric)('httpFailures');
-                (0, logger_1.log)(status >= 500 ? 'warn' : 'error', 'http.fail', { accountId, status, url: options.url });
+                const err = new errors_1.LinkedInClientError(`LinkedIn request failed: ${status}`, "REQUEST_FAILED", status, accountId);
+                (0, metrics_1.incrementMetric)("httpFailures");
+                (0, logger_1.log)(status >= 500 ? "warn" : "error", "http.fail", {
+                    accountId,
+                    status,
+                    url: redactUrlForLogging(options.url),
+                });
                 try {
                     (0, request_history_1.recordRequest)({
                         operation: op,
@@ -260,21 +340,24 @@ async function executeLinkedInRequest(options, _operationName) {
         }
         // Exhausted all accounts
         const errMsg = `All ${accountsTriedCount} LinkedIn accounts exhausted`;
-        (0, logger_1.log)('error', 'http.allAccountsExhausted', { accountsTriedCount, maxRotations });
+        (0, logger_1.log)("error", "http.allAccountsExhausted", {
+            accountsTriedCount,
+            maxRotations,
+        });
         // Report critical failure to Sentry
         try {
-            const { reportCriticalError } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
+            const { reportCriticalError } = await Promise.resolve().then(() => __importStar(require("./utils/sentry")));
             reportCriticalError(errMsg, {
                 accountsTriedCount,
                 maxRotations,
                 lastError: lastError?.message,
-                tags: { component: 'http-client', severity: 'critical' },
+                tags: { component: "http-client", severity: "critical" },
             });
         }
         catch { }
         if (lastError)
             throw lastError;
-        throw new errors_1.LinkedInClientError(errMsg, 'ALL_ACCOUNTS_FAILED', 503);
+        throw new errors_1.LinkedInClientError(errMsg, "ALL_ACCOUNTS_FAILED", 503);
     }
     finally {
         // Restore proxy env
@@ -287,7 +370,7 @@ async function executeLinkedInRequest(options, _operationName) {
                 delete process.env.HTTPS_PROXY;
             else
                 process.env.HTTPS_PROXY = prevHttps;
-            (0, logger_1.log)('info', 'proxy.restore', {});
+            (0, logger_1.log)("info", "proxy.restore", {});
         }
     }
 }
@@ -300,13 +383,13 @@ function parseProxyString(input) {
     if (/^\w+:\/\//.test(s)) {
         try {
             const u = new URL(s);
-            if (u.protocol !== 'http:' && u.protocol !== 'https:') {
-                throw new errors_1.LinkedInClientError(`Unsupported proxy protocol: ${u.protocol}`, 'INVALID_CONFIG', 400);
+            if (u.protocol !== "http:" && u.protocol !== "https:") {
+                throw new errors_1.LinkedInClientError(`Unsupported proxy protocol: ${u.protocol}`, "INVALID_CONFIG", 400);
             }
-            const user = u.username || '';
-            const pass = u.password || '';
+            const user = u.username || "";
+            const pass = u.password || "";
             const hostport = u.host; // includes brackets for IPv6
-            const url = `${u.protocol}//${user ? `${user}:${pass}@` : ''}${hostport}`;
+            const url = `${u.protocol}//${user ? `${user}:${pass}@` : ""}${hostport}`;
             const masked = user ? `${hostport}:${user}:***` : hostport;
             return { url, masked };
         }
@@ -323,15 +406,15 @@ function parseProxyString(input) {
         const user = m[3];
         const pass = m[4];
         // Ensure brackets for IPv6 in URL
-        const needsBrackets = host.includes(':') && !/^\[.*\]$/.test(host);
+        const needsBrackets = host.includes(":") && !/^\[.*\]$/.test(host);
         if (needsBrackets)
             host = `[${host}]`;
-        const auth = user && pass ? `${user}:${pass}@` : '';
+        const auth = user && pass ? `${user}:${pass}@` : "";
         const url = `http://${auth}${host}:${port}`;
         const hostport = `${host}:${port}`;
         const masked = user && pass ? `${hostport}:${user}:***` : hostport;
         return { url, masked };
     }
     // Fallback: conservative
-    return { url: s.includes('://') ? s : `http://${s}`, masked: '***' };
+    return { url: s.includes("://") ? s : `http://${s}`, masked: "***" };
 }

package/dist/linkedin-api.d.ts

@@ -1,7 +1,79 @@
-import type { SalesSearchFilters } from './types';
-import type { LinkedInProfile, SalesLeadSearchResult, SearchSalesResult, TypeaheadResult, SalesNavigatorProfile, Company } from './types';
+import type { SalesSearchFilters } from "./types";
+import type { LinkedInProfile, SearchSalesResult, TypeaheadResult, SalesNavigatorProfile, Company } from "./types";
+/**
+ * Fetches a LinkedIn profile by vanity URL (public identifier).
+ * Results are cached for the configured TTL (default: 15 minutes).
+ *
+ * @param vanity - The public identifier from LinkedIn URL (e.g., "johndoe" from linkedin.com/in/johndoe)
+ * @returns Parsed LinkedInProfile with positions, education, skills, and metadata
+ * @throws LinkedInClientError with code NOT_FOUND if profile doesn't exist
+ * @throws LinkedInClientError with code PARSE_ERROR if response cannot be parsed
+ *
+ * @example
+ * ```typescript
+ * const profile = await getProfileByVanity('johndoe');
+ * console.log(profile.firstName, profile.headline);
+ * ```
+ */
 export declare function getProfileByVanity(vanity: string): Promise<LinkedInProfile>;
+/**
+ * Fetches a LinkedIn profile by FSD key or URN.
+ * Accepts multiple input formats and normalizes them.
+ * Results are cached for the configured TTL (default: 15 minutes).
+ *
+ * @param fsdKey - Profile identifier in any of these formats:
+ *   - Bare key: "ABC123xyz"
+ *   - FSD profile URN: "urn:li:fsd_profile:ABC123xyz"
+ *   - Sales profile URN: "urn:li:fs_salesProfile:(ABC123xyz,NAME_SEARCH,abc)"
+ * @returns Parsed LinkedInProfile with positions, education, skills, and metadata
+ * @throws LinkedInClientError with code INVALID_INPUT if URN format is invalid
+ * @throws LinkedInClientError with code NOT_FOUND if profile doesn't exist
+ * @throws LinkedInClientError with code PARSE_ERROR if response cannot be parsed
+ *
+ * @example
+ * ```typescript
+ * // By bare key
+ * const profile = await getProfileByUrn('ABC123xyz');
+ *
+ * // By URN from search results
+ * const profile = await getProfileByUrn(searchResult.salesProfileUrn);
+ * ```
+ */
 export declare function getProfileByUrn(fsdKey: string): Promise<LinkedInProfile>;
+/**
+ * Searches Sales Navigator for leads matching the given criteria.
+ * Supports pagination, advanced filters, and session-based account stickiness.
+ *
+ * @param keywords - Search keywords (max 2000 characters)
+ * @param options - Search configuration options
+ * @param options.start - Pagination offset (default: 0)
+ * @param options.count - Results per page (default: 25)
+ * @param options.decorationId - LinkedIn decoration ID for response format
+ * @param options.filters - Advanced search filters (title, company, geography, etc.)
+ * @param options.rawQuery - Raw query string (bypasses filter encoding)
+ * @param options.sessionId - Session ID for consistent pagination (same account across pages)
+ * @returns SearchSalesResult with items array, pagination info, and session metadata
+ * @throws LinkedInClientError with code INVALID_INPUT if keywords exceed max length
+ *
+ * @example
+ * ```typescript
+ * // Simple search
+ * const results = await searchSalesLeads('CEO');
+ *
+ * // Paginated search with session persistence
+ * const page1 = await searchSalesLeads('CEO', { start: 0, count: 25 });
+ * const sessionId = page1._meta?.sessionId;
+ * const page2 = await searchSalesLeads('CEO', { start: 25, count: 25, sessionId });
+ *
+ * // With filters
+ * const filtered = await searchSalesLeads('', {
+ *   filters: {
+ *     role: { seniority_ids: [8, 9, 10] }, // VP, CXO, Partner
+ *     company: { headcount: { include: ['501-1000', '1001-5000'] } }
+ *   }
+ * });
+ * ```
+ */
 export declare function searchSalesLeads(keywords: string, options?: {
     start?: number;
     count?: number;
@@ -9,20 +81,41 @@ export declare function searchSalesLeads(keywords: string, options?: {
     filters?: SalesSearchFilters;
     rawQuery?: string;
     sessionId?: string;
-}): Promise<SearchSalesResult | SalesLeadSearchResult[]>;
+}): Promise<SearchSalesResult>;
 export declare function getProfilesBatch(vanities: string[], concurrency?: number): Promise<(LinkedInProfile | null)[]>;
 export declare function resolveCompanyUniversalName(universalName: string): Promise<{
     companyId?: string;
 }>;
+/**
+ * Fetches a company by its numeric LinkedIn ID.
+ * Results are cached for the configured TTL (default: 10 minutes).
+ *
+ * @param companyId - Numeric company ID (e.g., "1234567")
+ * @returns Company object with name, description, size, headquarters, etc.
+ * @throws LinkedInClientError with code NOT_FOUND if company doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const company = await getCompanyById('1234567');
+ * console.log(company.name, company.sizeLabel);
+ * ```
+ */
 export declare function getCompanyById(companyId: string): Promise<Company>;
 export declare function getCompanyByUrl(companyUrl: string): Promise<Company>;
+/**
+ * Fetch multiple companies in parallel with controlled concurrency.
+ * @param companyIds - Array of company IDs (numeric strings)
+ * @param concurrency - Maximum parallel requests (default: 4, max: 16)
+ * @returns Array of Company objects (null for failed fetches, preserves order)
+ */
+export declare function getCompaniesBatch(companyIds: string[], concurrency?: number): Promise<(Company | null)[]>;
 export declare function typeahead(options: {
     type: string;
     query?: string;
     start?: number;
     count?: number;
 }): Promise<TypeaheadResult>;
-export { YEARS_OPTIONS as YEARS_AT_COMPANY_OPTIONS, YEARS_OPTIONS as YEARS_IN_POSITION_OPTIONS, YEARS_OPTIONS as YEARS_OF_EXPERIENCE_OPTIONS, SENIORITY_OPTIONS, FUNCTION_OPTIONS, REGION_OPTIONS, LANGUAGE_OPTIONS, INDUSTRY_OPTIONS, COMPANY_SIZE_OPTIONS, } from './constants';
+export { YEARS_OPTIONS as YEARS_AT_COMPANY_OPTIONS, YEARS_OPTIONS as YEARS_IN_POSITION_OPTIONS, YEARS_OPTIONS as YEARS_OF_EXPERIENCE_OPTIONS, SENIORITY_OPTIONS, FUNCTION_OPTIONS, REGION_OPTIONS, LANGUAGE_OPTIONS, INDUSTRY_OPTIONS, COMPANY_SIZE_OPTIONS, } from "./constants";
 /**
  * Returns static years at company options (no API call needed)
  */