linkedin-api-voyager 1.0.0 → 1.1.0

package/lib/account.d.ts

@@ -0,0 +1,18 @@
+export declare const getProfile: (identifier: string) => Promise<{
+    publicIdentifier: any;
+    firstName: any;
+    lastName: any;
+    fullName: string;
+    birthDate: string | null;
+    profilePicture: string | null;
+    backgroundPicture: string | null;
+    location: {
+        country: any;
+        city: any;
+    };
+    address: any;
+    industry: any;
+    headline: any;
+    summary: any;
+}>;
+export declare const getProfissionalExperiences: (identifier: string) => Promise<any[]>;

package/lib/account.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProfissionalExperiences = exports.getProfile = void 0;
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+const getProfile = (identifier) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const response = yield (0, config_1.fetchData)(`/identity/profiles/${identifier}/profileView`);
+    const data = response.data;
+    const dataResult = response === null || response === void 0 ? void 0 : response.included;
+    const getEntityByUrn = (urn) => dataResult.find((item) => item.entityUrn === urn);
+    const keyProfile = getEntityByUrn(data === null || data === void 0 ? void 0 : data["*profile"]);
+    if (!keyProfile)
+        throw new Error("Key profile not found");
+    const miniProfile = getEntityByUrn(keyProfile === null || keyProfile === void 0 ? void 0 : keyProfile["*miniProfile"]);
+    if (!miniProfile)
+        throw new Error("Mini profile not found");
+    const profile = {
+        // id_urn: keyProfile.entityUrn?.split("urn:li:fs_profile:")[1] || null,
+        publicIdentifier: (miniProfile === null || miniProfile === void 0 ? void 0 : miniProfile.publicIdentifier) || null,
+        firstName: keyProfile.firstName || null,
+        lastName: keyProfile.lastName || null,
+        fullName: `${keyProfile.firstName || ""} ${keyProfile.lastName || ""}`,
+        birthDate: keyProfile.birthDate
+            ? JSON.stringify({
+                month: keyProfile.birthDate.month,
+                day: keyProfile.birthDate.day,
+            })
+            : null,
+        profilePicture: miniProfile.picture
+            ? `${miniProfile.picture.rootUrl}${(_a = miniProfile.picture.artifacts[miniProfile.picture.artifacts.length - 1]) === null || _a === void 0 ? void 0 : _a.fileIdentifyingUrlPathSegment}`
+            : null,
+        backgroundPicture: miniProfile.backgroundImage
+            ? `${miniProfile.backgroundImage.rootUrl}${(_b = miniProfile.backgroundImage.artifacts[miniProfile.backgroundImage.artifacts.length - 1]) === null || _b === void 0 ? void 0 : _b.fileIdentifyingUrlPathSegment}`
+            : null,
+        location: {
+            country: keyProfile.locationName || null,
+            city: keyProfile.geoLocationName || null,
+        },
+        address: keyProfile.address || null,
+        industry: keyProfile.industryName || null,
+        headline: keyProfile.headline || null,
+        summary: keyProfile.summary || null,
+    };
+    return profile;
+});
+exports.getProfile = getProfile;
+const getProfissionalExperiences = (identifier) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield (0, config_1.fetchData)(`/identity/profiles/${identifier}/positions`);
+    let { data, included } = response;
+    const elements = data["*elements"];
+    // Usar a nova função para resolver referências automaticamente
+    const dataExperiences = (0, utils_1.extractDataWithReferences)(elements, included);
+    // Extrair campos específicos do included
+    const extraFields = (0, utils_1.extractFieldsFromIncluded)(included, ["universalName"]);
+    // Mapeamento de campos
+    const fieldsMap = {
+        id: "entityUrn",
+        title: "title",
+        companyName: "company.miniCompany.name",
+        companyUrn: "companyUrn",
+        companyEmployeeCount: "company.employeeCountRange",
+        companyIndustries: "company.miniCompany.industries",
+        description: "description",
+        location: "locationName",
+        geoLocation: "geoLocationName",
+        timePeriod: "timePeriod",
+        startDate: "timePeriod.startDate",
+        endDate: "timePeriod.endDate",
+    };
+    // Aplicar mapeamento aos dados resolvidos
+    const mappedExperiences = (0, utils_1.extractFields)(dataExperiences, fieldsMap);
+    // Associar campos extras
+    const experiencesWithExtras = (0, utils_1.mergeExtraFields)(mappedExperiences, extraFields, "companyUrn");
+    // Ordenar: sem endDate (ativo) primeiro, depois do mais recente ao mais antigo
+    return experiencesWithExtras.sort((a, b) => {
+        if (!a.endDate && b.endDate)
+            return -1;
+        if (a.endDate && !b.endDate)
+            return 1;
+        if (!a.endDate && !b.endDate)
+            return 0;
+        const yearDiff = (b.endDate.year || 0) - (a.endDate.year || 0);
+        if (yearDiff !== 0)
+            return yearDiff;
+        return (b.endDate.month || 0) - (a.endDate.month || 0);
+    });
+});
+exports.getProfissionalExperiences = getProfissionalExperiences;

package/lib/company.d.ts

@@ -0,0 +1 @@
+export declare const getCompany: (identifier: string) => Promise<any>;

package/lib/company.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompany = void 0;
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+const getCompany = (identifier) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield (0, config_1.fetchData)(`/organization/companies?decorationId=com.linkedin.voyager.deco.organization.web.WebFullCompanyMain-12&q=universalName&universalName=${identifier}`);
+    const data = (0, utils_1.extractDataWithReferences)(response.data["*elements"], response.included);
+    const fieldsMap = {
+        id: "entityUrn",
+        name: "name",
+        description: "description",
+        username: "universalName",
+        companyPageUrl: "companyPageUrl",
+        staffCount: "staffCount",
+        url: "url",
+        companyIndustries: "*companyIndustries[0].localizedName",
+        location: "locationName",
+        jobSearchPageUrl: "jobSearchPageUrl",
+        phone: "phone",
+        followerCount: "followingInfo.followerCount",
+        backgroundCoverImage: "backgroundCoverImage.image",
+        logo: "logo.image",
+        permissions: "permissions",
+    };
+    return (0, utils_1.extractFields)(data, fieldsMap)[0];
+});
+exports.getCompany = getCompany;

package/lib/config.d.ts

@@ -0,0 +1,20 @@
+export declare const COOKIE_FILE_PATH = "linkedin_cookies.json";
+export declare const API_BASE_URL = "https://www.linkedin.com/voyager/api";
+export declare const AUTH_BASE_URL = "https://www.linkedin.com";
+interface LinkedInCookies {
+    JSESSIONID: string;
+    li_at: string;
+    timestamp: number;
+}
+export declare const saveCookies: (JSESSIONID: string, li_at: string) => Promise<void>;
+export declare const loadCookies: () => Promise<LinkedInCookies | null>;
+export declare const Client: (providedCookies?: {
+    JSESSIONID: string;
+    li_at: string;
+}) => Promise<ReturnType<typeof api>>;
+declare const api: ({ JSESSIONID, li_at }: {
+    li_at: string;
+    JSESSIONID: number;
+}) => import("axios").AxiosInstance;
+export declare const fetchData: (endpoint: string) => Promise<any>;
+export {};

package/lib/config.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchData = exports.Client = exports.loadCookies = exports.saveCookies = exports.AUTH_BASE_URL = exports.API_BASE_URL = exports.COOKIE_FILE_PATH = void 0;
+const fs = require("fs-extra");
+const axios_1 = require("axios");
+exports.COOKIE_FILE_PATH = "linkedin_cookies.json";
+exports.API_BASE_URL = "https://www.linkedin.com/voyager/api";
+exports.AUTH_BASE_URL = "https://www.linkedin.com";
+// Função para salvar cookies no arquivo JSON
+const saveCookies = (JSESSIONID, li_at) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const cookies = {
+            JSESSIONID,
+            li_at,
+            timestamp: Date.now(),
+        };
+        yield fs.ensureFile(exports.COOKIE_FILE_PATH);
+        yield fs.writeJson(exports.COOKIE_FILE_PATH, cookies, { spaces: 2 });
+        console.log(`Cookies salvos em: ${exports.COOKIE_FILE_PATH}`);
+    }
+    catch (error) {
+        console.error("Erro ao salvar cookies:", error);
+        throw error;
+    }
+});
+exports.saveCookies = saveCookies;
+// Função para carregar cookies do arquivo JSON
+const loadCookies = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const exists = yield fs.pathExists(exports.COOKIE_FILE_PATH);
+        if (!exists) {
+            console.log("Arquivo de cookies não encontrado");
+            return null;
+        }
+        const cookies = yield fs.readJson(exports.COOKIE_FILE_PATH);
+        // Verificar se os cookies têm a estrutura esperada
+        if (!cookies.JSESSIONID || !cookies.li_at) {
+            console.log("Cookies inválidos encontrados no arquivo");
+            return null;
+        }
+        console.log(`Cookies carregados de: ${exports.COOKIE_FILE_PATH}`);
+        return cookies;
+    }
+    catch (error) {
+        console.error("Erro ao carregar cookies:", error);
+        return null;
+    }
+});
+exports.loadCookies = loadCookies;
+// Função para criar cliente com cookies automáticos
+const Client = (providedCookies) => __awaiter(void 0, void 0, void 0, function* () {
+    let cookiesToUse;
+    const savedCookies = yield (0, exports.loadCookies)();
+    if (savedCookies) {
+        cookiesToUse = {
+            JSESSIONID: savedCookies.JSESSIONID,
+            li_at: savedCookies.li_at,
+        };
+    }
+    else {
+        if (providedCookies) {
+            yield (0, exports.saveCookies)(providedCookies.JSESSIONID, providedCookies.li_at);
+            cookiesToUse = providedCookies;
+        }
+        else {
+            throw new Error("Nenhum cookie válido fornecido");
+        }
+    }
+    return api({
+        JSESSIONID: parseInt(cookiesToUse.JSESSIONID),
+        li_at: cookiesToUse.li_at,
+    });
+});
+exports.Client = Client;
+const api = ({ JSESSIONID, li_at }) => {
+    return axios_1.default.create({
+        baseURL: exports.API_BASE_URL,
+        headers: {
+            "accept-language": "pt-BR,pt;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
+            accept: "application/vnd.linkedin.normalized+json+2.1",
+            cookie: `li_at=${li_at}; JSESSIONID="ajax:${JSESSIONID}"`,
+            "csrf-token": `ajax:${JSESSIONID}`,
+        },
+    });
+};
+const fetchData = (endpoint) => __awaiter(void 0, void 0, void 0, function* () {
+    const api = yield (0, exports.Client)();
+    const response = yield api.get(endpoint);
+    return response.data;
+});
+exports.fetchData = fetchData;

package/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./account"), exports);
+__exportStar(require("./company"), exports);
+__exportStar(require("./posts"), exports);
+__exportStar(require("./search"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./config"), exports);

package/lib/linkedin.js

@@ -0,0 +1 @@
+"use strict";

package/lib/posts.d.ts

@@ -0,0 +1,2 @@
+export declare const getCommentsByPostUrl: (url: string, start?: number, limit?: number, accumulatedComments?: any[]) => Promise<any[]>;
+export declare const getPosts: () => Promise<never[]>;

package/lib/posts.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPosts = exports.getCommentsByPostUrl = void 0;
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+const getCommentsByPostUrl = (url_1, ...args_1) => __awaiter(void 0, [url_1, ...args_1], void 0, function* (url, start = 0, limit = 50, accumulatedComments = []) {
+    var _a, _b, _c, _d, _e;
+    const postID = (_a = url.match(/activity-(\d+)/)) === null || _a === void 0 ? void 0 : _a[1];
+    const response = yield (0, config_1.fetchData)(`/graphql?includeWebMetadata=false&queryId=voyagerSocialDashComments.95ed44bc87596acce7c460c70934d0ff&variables=(count:${limit},start:${start},numReplies:1,socialDetailUrn:urn%3Ali%3Afsd_socialDetail%3A%28urn%3Ali%3Aactivity%${postID}%2Curn%3Ali%3Aactivity%3A${postID}%2Curn%3Ali%3AhighlightedReply%3A-%29,sortOrder:RELEVANCE)`);
+    const elements = (_d = (_c = (_b = response.data) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.socialDashCommentsBySocialDetail) === null || _d === void 0 ? void 0 : _d["*elements"];
+    // Se não há elementos, retorna os comentários acumulados
+    if (!elements || elements.length === 0) {
+        // console.log(
+        //   "✅ Busca finalizada. Total de comentários:",
+        //   accumulatedComments.length
+        // );
+        return accumulatedComments;
+    }
+    const data = ((_e = response.included) === null || _e === void 0 ? void 0 : _e.filter((item) => elements.includes(item.entityUrn))) || [];
+    // Mapeamento melhorado dos campos
+    const fieldsMap = {
+        id: "entityUrn",
+        createdAt: "createdAt",
+        isAuthor: "commenter.author",
+        name: "commenter.title.text",
+        headline: "commenter.subtitle",
+        profileUrl: "commenter.navigationUrl",
+        comment: "commentary.text",
+        permalink: "permalink",
+        image: "commenter.image.attributes.0.detailData.nonEntityProfilePicture.vectorImage",
+    };
+    const currentComments = (0, utils_1.extractFields)(data, fieldsMap);
+    const allComments = [...accumulatedComments, ...currentComments];
+    //   console.log(
+    //     `🔍 Encontrados ${elements.length} comentários (Total: ${allComments.length})`
+    //   );
+    // Continua a busca se há mais elementos
+    if (elements.length > 0) {
+        return yield (0, exports.getCommentsByPostUrl)(url, start + elements.length, limit, allComments);
+    }
+    // Se retornou menos que o limite, chegou ao fim
+    return allComments;
+});
+exports.getCommentsByPostUrl = getCommentsByPostUrl;
+const getPosts = () => __awaiter(void 0, void 0, void 0, function* () {
+    return [];
+});
+exports.getPosts = getPosts;

package/lib/search.d.ts

@@ -0,0 +1,26 @@
+export interface SearchParams {
+    count?: string;
+    filters?: string;
+    origin?: string;
+    q?: string;
+    start?: number;
+    queryContext?: string;
+    [key: string]: any;
+}
+export interface SearchElement {
+    [key: string]: any;
+}
+export interface SearchDataElement {
+    elements: SearchElement[];
+    extendedElements?: SearchElement[];
+}
+export interface SearchResponse {
+    data: {
+        elements: SearchDataElement[];
+    };
+}
+export interface SearchOptions {
+    limit?: number;
+    results?: SearchElement[];
+}
+export declare const search: (params: SearchParams, options?: SearchOptions) => Promise<SearchElement[]>;

package/lib/search.js

@@ -0,0 +1,133 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search = void 0;
+const config_1 = require("./config");
+// Constantes
+const MAX_SEARCH_COUNT = 25;
+const MAX_REPEATED_REQUESTS = 40;
+// Função utilitária para criar query string
+const createQueryString = (params) => {
+    return Object.entries(params)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+        .join("&");
+};
+// Função utilitária para fazer fetch (assumindo que existe uma função _fetch no client)
+const fetchData = (endpoint) => __awaiter(void 0, void 0, void 0, function* () {
+    const api = yield (0, config_1.Client)();
+    const response = yield api.get(endpoint);
+    return response.data;
+});
+// Função principal de busca
+const search = (params_1, ...args_1) => __awaiter(void 0, [params_1, ...args_1], void 0, function* (params, options = {}) {
+    const { limit, results = [] } = options;
+    // Determinar o count baseado no limite
+    const count = limit && limit <= MAX_SEARCH_COUNT ? limit : MAX_SEARCH_COUNT;
+    // Parâmetros padrão
+    const defaultParams = {
+        count: count.toString(),
+        filters: "List()",
+        origin: "GLOBAL_SEARCH_HEADER",
+        q: "all",
+        start: results.length,
+        queryContext: "List(spellCorrectionEnabled->true,relatedSearchesEnabled->true,kcardTypes->PROFILE|COMPANY)",
+    };
+    // Mesclar parâmetros padrão com os fornecidos
+    const mergedParams = Object.assign(Object.assign({}, defaultParams), params);
+    // Fazer a requisição
+    const endpoint = `/search/blended?${createQueryString(mergedParams)}`;
+    const response = yield fetchData(endpoint);
+    // Processar os dados da resposta
+    const newElements = [];
+    if (response.data && response.data.elements) {
+        for (let i = 0; i < response.data.elements.length; i++) {
+            if (response.data.elements[i].elements) {
+                newElements.push(...response.data.elements[i].elements);
+            }
+            // Comentário: não tenho certeza do que extendedElements geralmente se refere
+            // - busca por palavra-chave retorna um único trabalho?
+            // if (response.data.elements[i].extendedElements) {
+            //   newElements.push(...response.data.elements[i].extendedElements);
+            // }
+        }
+    }
+    // Adicionar novos elementos aos resultados
+    const updatedResults = [...results, ...newElements];
+    // Sempre cortar os resultados, não importa o que a requisição retorna
+    const trimmedResults = limit
+        ? updatedResults.slice(0, limit)
+        : updatedResults;
+    // Caso base da recursão
+    const shouldStop = (limit !== undefined &&
+        (trimmedResults.length >= limit || // se nossos resultados excedem o limite definido
+            trimmedResults.length / count >= MAX_REPEATED_REQUESTS)) ||
+        newElements.length === 0;
+    if (shouldStop) {
+        return trimmedResults;
+    }
+    // Chamada recursiva
+    return (0, exports.search)(params, {
+        limit,
+        results: trimmedResults,
+    });
+});
+exports.search = search;
+// Função auxiliar para busca simples (não recursiva)
+// export const searchSingle = async (
+//   client: ClientState,
+//   params: SearchParams
+// ): Promise<SearchElement[]> => {
+//   return search(client, params, { limit: MAX_SEARCH_COUNT });
+// };
+// // Função para busca com limite específico
+// export const searchWithLimit = async (
+//   client: ClientState,
+//   params: SearchParams,
+//   limit: number
+// ): Promise<SearchElement[]> => {
+//   return search(client, params, { limit });
+// };
+// // Função para busca de pessoas
+// export const searchPeople = async (
+//   client: ClientState,
+//   query: string,
+//   limit?: number
+// ): Promise<SearchElement[]> => {
+//   const params: SearchParams = {
+//     keywords: query,
+//     filters: "List(resultType->PEOPLE)",
+//   };
+//   return search(client, params, { limit });
+// };
+// // Função para busca de empresas
+// export const searchCompanies = async (
+//   client: ClientState,
+//   query: string,
+//   limit?: number
+// ): Promise<SearchElement[]> => {
+//   const params: SearchParams = {
+//     keywords: query,
+//     filters: "List(resultType->COMPANIES)",
+//   };
+//   return search(client, params, { limit });
+// };
+// // Função para busca de empregos
+// export const searchJobs = async (
+//   client: ClientState,
+//   query: string,
+//   limit?: number
+// ): Promise<SearchElement[]> => {
+//   const params: SearchParams = {
+//     keywords: query,
+//     filters: "List(resultType->JOBS)",
+//   };
+//   return search(client, params, { limit });
+// };

package/lib/utils.d.ts

@@ -0,0 +1,10 @@
+export declare function filterKeys(obj: any, keysToKeep: string[]): any;
+export declare function filterOutKeys(obj: any, keysToIgnore: string[]): any;
+export declare function getNestedValue(obj: any, path: string): any;
+export declare function extractFields(data: any[], fieldsMap: Record<string, string>): any[];
+export declare function debugObjectStructure(obj: any, maxDepth?: number, currentDepth?: number): void;
+export declare function resolveReferences(data: any, included: any[]): any;
+export declare function extractDataWithReferences(elements: string[], included: any[], fieldsMap?: Record<string, string>): any[];
+export declare function debugResolvedStructure(elements: string[], included: any[], maxDepth?: number): void;
+export declare function extractFieldsFromIncluded(included: any[], fields: string[]): Record<string, any>[];
+export declare function mergeExtraFields(mainData: any[], extraData: Record<string, any>[], matchKey?: string): any[];