orangeslice 2.1.5 → 2.3.0-beta.0

package/README.md

@@ -90,8 +90,10 @@ const startups = await services.crunchbase.search({
 ## Service map
 
 - `services.company.linkedin.search/enrich`
+- `services.company.findCareersPage/scrapeCareersPage`
 - `services.crunchbase.search` (returns rows array directly)
 - `services.company.getEmployeesFromLinkedin` (database-only B2B path)
+- `services.ocean.search.companies/people`
 - `services.person.linkedin.search/enrich`
 - `services.web.search/batchSearch`
 - `services.ai.generateObject`
@@ -106,7 +108,7 @@ const startups = await services.crunchbase.search({
 
 All service calls go through `post()` in `src/api.ts`.
 
-- Submit path: `https://enrichly-production.up.railway.app/function`
+- Execute paths: `https://enrichly-production.up.railway.app/execute/*` and `https://enrichly-production.up.railway.app/ctx/*`
 - Pending responses (`pending: true` / `202`) poll batch-service result endpoints.
 - Polling timeout supports long-running workflows (up to 10 minutes).
 - This package now exposes only batch-backed services.

package/dist/careers.d.ts

@@ -0,0 +1,47 @@
+export interface FindCareersPageParams {
+    website?: string;
+    url?: string;
+}
+export interface FindCareersPageResult {
+    inputUrl: string;
+    normalizedWebsiteUrl: string;
+    careerPageUrl: string | null;
+    pageType: "ats" | "official" | "not_found";
+    atsProvider: string | null;
+    detectionMethod: "input-ats" | "homepage-ats-link" | "homepage-careers-link" | "deterministic-candidate" | "candidate-ats-link" | "embedded-ats" | "candidate-redirect" | "ats-unverified" | "not-found";
+    checkedUrls: string[];
+}
+export interface ScrapeCareersPageParams {
+    careersPageUrl?: string;
+    url?: string;
+}
+export interface ScrapeCareersPageJob {
+    id: string;
+    title: string;
+    url: string;
+    applyUrl: string | null;
+    location: string | null;
+    locations: string[];
+    department: string | null;
+    team: string | null;
+    employmentType: string | null;
+    workplaceType: string | null;
+    postedAt: string | null;
+    postedText: string | null;
+    requisitionId: string | null;
+}
+export interface ScrapeCareersPageResult {
+    status: "success" | "unsupported_url" | "unsupported_provider";
+    inputUrl: string;
+    normalizedBoardUrl: string | null;
+    atsProvider: string | null;
+    companyName: string | null;
+    source: "api" | "html" | null;
+    totalJobs: number;
+    jobs: ScrapeCareersPageJob[];
+    checkedUrls: string[];
+    supportedProviders: string[];
+    message: string | null;
+}
+export declare function findCareersPage(params: FindCareersPageParams): Promise<FindCareersPageResult>;
+export declare function scrapeCareersPage(params: ScrapeCareersPageParams): Promise<ScrapeCareersPageResult>;

package/dist/careers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCareersPage = findCareersPage;
+exports.scrapeCareersPage = scrapeCareersPage;
+const api_1 = require("./api");
+async function findCareersPage(params) {
+    return (0, api_1.post)("/execute/find-careers-page", { ...params });
+}
+async function scrapeCareersPage(params) {
+    return (0, api_1.post)("/execute/scrape-careers-page", { ...params });
+}

package/dist/index.d.ts

@@ -1,11 +1,19 @@
 export { configure } from "./api";
 export type { OrangesliceConfig } from "./api";
+export { integrations } from "./integrations";
+export type { Integration, IntegrationProvider, IntegrationListParams, IntegrationCreateParams, IntegrationUpdateParams, IntegrationConnectOptions } from "./integrations";
+export { skills } from "./skills";
+export type { Skill, SkillListParams, SkillCreateParams, SkillUpdateParams } from "./skills";
+export { findCareersPage, scrapeCareersPage } from "./careers";
+export type { FindCareersPageParams, FindCareersPageResult, ScrapeCareersPageParams, ScrapeCareersPageResult, ScrapeCareersPageJob } from "./careers";
 export { ctx } from "./ctx";
 export type { Spreadsheet, SpreadsheetListItem, SqlResult, SqlQueryResult, SqlActionResult, RowsAddResult } from "./ctx";
 export { linkedinSearch } from "./b2b";
 export type { LinkedInSearchParams, LinkedInSearchResponse } from "./b2b";
 export { crunchbaseSearch } from "./crunchbase";
 export type { CrunchbaseSearchParams } from "./crunchbase";
+export { executeOcean, oceanSearchCompanies, oceanSearchPeople, OCEAN_OPERATION_IDS } from "./ocean";
+export type { OceanOperationId, OceanCompaniesFilters, OceanPeopleFilters, OceanCompaniesSearchParams, OceanCompaniesSearchResponse, OceanCompanyResult, OceanCompanyMatch, OceanPeopleSearchParams, OceanPeopleSearchResponse, OceanPersonResult } from "./ocean";
 export { webSearch, webBatchSearch } from "./serp";
 export type { WebSearchQuery, WebSearchResult, WebSearchResponse, BatchWebSearchParams } from "./serp";
 export { generateObject } from "./generateObject";
@@ -25,11 +33,13 @@ export type { PersonLinkedinFindUrlParams, CompanyLinkedinFindUrlParams, PersonC
 import { runApifyActor } from "./apify";
 import { linkedinSearch } from "./b2b";
 import { browserExecute } from "./browser";
+import { findCareersPage, scrapeCareersPage } from "./careers";
 import { crunchbaseSearch } from "./crunchbase";
 import { personLinkedinEnrich, personLinkedinFindUrl, personContactGet, companyLinkedinEnrich, companyLinkedinFindUrl, companyGetEmployeesFromLinkedin, geoParseAddress, builtWithLookupDomain, builtWithRelationships, builtWithSearchByTech } from "./expansion";
 import { scrapeWebsite } from "./firecrawl";
 import { generateObject } from "./generateObject";
 import { googleMapsScrape } from "./googleMaps";
+import { oceanSearchCompanies, oceanSearchPeople } from "./ocean";
 import { webBatchSearch, webSearch } from "./serp";
 export declare const services: {
     crunchbase: {
@@ -42,6 +52,8 @@ export declare const services: {
             search: typeof linkedinSearch;
         };
         getEmployeesFromLinkedin: typeof companyGetEmployeesFromLinkedin;
+        findCareersPage: typeof findCareersPage;
+        scrapeCareersPage: typeof scrapeCareersPage;
     };
     person: {
         linkedin: {
@@ -75,11 +87,40 @@ export declare const services: {
     googleMaps: {
         scrape: typeof googleMapsScrape;
     };
+    ocean: {
+        search: {
+            companies: typeof oceanSearchCompanies;
+            people: typeof oceanSearchPeople;
+        };
+    };
     builtWith: {
         lookupDomain: typeof builtWithLookupDomain;
         relationships: typeof builtWithRelationships;
         searchByTech: typeof builtWithSearchByTech;
     };
     predictLeads: Readonly<import("./predictLeads").PredictLeadsServiceMap>;
+    integrations: {
+        connect: (provider: import("./integrations").IntegrationProvider, opts?: import("./integrations").IntegrationConnectOptions) => Promise<import("./integrations").Integration>;
+        list: (opts?: import("./integrations").IntegrationListParams) => Promise<{
+            integrations: import("./integrations").Integration[];
+        }>;
+        get: (id: string) => Promise<import("./integrations").Integration>;
+        create: (opts: import("./integrations").IntegrationCreateParams) => Promise<import("./integrations").Integration>;
+        update: (id: string, fields: import("./integrations").IntegrationUpdateParams) => Promise<import("./integrations").Integration>;
+        delete: (id: string) => Promise<{
+            success: boolean;
+        }>;
+    };
+    skills: {
+        list: (opts?: import("./skills").SkillListParams) => Promise<{
+            skills: import("./skills").Skill[];
+        }>;
+        get: (id: string) => Promise<import("./skills").Skill>;
+        create: (opts: import("./skills").SkillCreateParams) => Promise<import("./skills").Skill>;
+        update: (id: string, fields: import("./skills").SkillUpdateParams) => Promise<import("./skills").Skill>;
+        delete: (id: string) => Promise<{
+            success: boolean;
+        }>;
+    };
 };
 export default services;

package/dist/index.js

@@ -1,14 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.services = exports.builtWithSearchByTech = exports.builtWithRelationships = exports.builtWithLookupDomain = exports.geoParseAddress = exports.companyGetEmployeesFromLinkedin = exports.companyLinkedinFindUrl = exports.companyLinkedinEnrich = exports.personContactGet = exports.personLinkedinFindUrl = exports.personLinkedinEnrich = exports.PREDICT_LEADS_OPERATION_IDS = exports.predictLeads = exports.executePredictLeads = exports.googleMapsScrape = exports.runApifyActor = exports.browserExecute = exports.scrapeWebsite = exports.generateObject = exports.webBatchSearch = exports.webSearch = exports.crunchbaseSearch = exports.linkedinSearch = exports.ctx = exports.configure = void 0;
+exports.services = exports.builtWithSearchByTech = exports.builtWithRelationships = exports.builtWithLookupDomain = exports.geoParseAddress = exports.companyGetEmployeesFromLinkedin = exports.companyLinkedinFindUrl = exports.companyLinkedinEnrich = exports.personContactGet = exports.personLinkedinFindUrl = exports.personLinkedinEnrich = exports.PREDICT_LEADS_OPERATION_IDS = exports.predictLeads = exports.executePredictLeads = exports.googleMapsScrape = exports.runApifyActor = exports.browserExecute = exports.scrapeWebsite = exports.generateObject = exports.webBatchSearch = exports.webSearch = exports.OCEAN_OPERATION_IDS = exports.oceanSearchPeople = exports.oceanSearchCompanies = exports.executeOcean = exports.crunchbaseSearch = exports.linkedinSearch = exports.ctx = exports.scrapeCareersPage = exports.findCareersPage = exports.skills = exports.integrations = exports.configure = void 0;
 var api_1 = require("./api");
 Object.defineProperty(exports, "configure", { enumerable: true, get: function () { return api_1.configure; } });
+var integrations_1 = require("./integrations");
+Object.defineProperty(exports, "integrations", { enumerable: true, get: function () { return integrations_1.integrations; } });
+var skills_1 = require("./skills");
+Object.defineProperty(exports, "skills", { enumerable: true, get: function () { return skills_1.skills; } });
+var careers_1 = require("./careers");
+Object.defineProperty(exports, "findCareersPage", { enumerable: true, get: function () { return careers_1.findCareersPage; } });
+Object.defineProperty(exports, "scrapeCareersPage", { enumerable: true, get: function () { return careers_1.scrapeCareersPage; } });
 var ctx_1 = require("./ctx");
 Object.defineProperty(exports, "ctx", { enumerable: true, get: function () { return ctx_1.ctx; } });
 var b2b_1 = require("./b2b");
 Object.defineProperty(exports, "linkedinSearch", { enumerable: true, get: function () { return b2b_1.linkedinSearch; } });
 var crunchbase_1 = require("./crunchbase");
 Object.defineProperty(exports, "crunchbaseSearch", { enumerable: true, get: function () { return crunchbase_1.crunchbaseSearch; } });
+var ocean_1 = require("./ocean");
+Object.defineProperty(exports, "executeOcean", { enumerable: true, get: function () { return ocean_1.executeOcean; } });
+Object.defineProperty(exports, "oceanSearchCompanies", { enumerable: true, get: function () { return ocean_1.oceanSearchCompanies; } });
+Object.defineProperty(exports, "oceanSearchPeople", { enumerable: true, get: function () { return ocean_1.oceanSearchPeople; } });
+Object.defineProperty(exports, "OCEAN_OPERATION_IDS", { enumerable: true, get: function () { return ocean_1.OCEAN_OPERATION_IDS; } });
 var serp_1 = require("./serp");
 Object.defineProperty(exports, "webSearch", { enumerable: true, get: function () { return serp_1.webSearch; } });
 Object.defineProperty(exports, "webBatchSearch", { enumerable: true, get: function () { return serp_1.webBatchSearch; } });
@@ -40,11 +52,15 @@ Object.defineProperty(exports, "builtWithSearchByTech", { enumerable: true, get:
 const apify_2 = require("./apify");
 const b2b_2 = require("./b2b");
 const browser_2 = require("./browser");
+const careers_2 = require("./careers");
 const crunchbase_2 = require("./crunchbase");
+const integrations_2 = require("./integrations");
+const skills_2 = require("./skills");
 const expansion_2 = require("./expansion");
 const firecrawl_2 = require("./firecrawl");
 const generateObject_2 = require("./generateObject");
 const googleMaps_2 = require("./googleMaps");
+const ocean_2 = require("./ocean");
 const predictLeads_2 = require("./predictLeads");
 const serp_2 = require("./serp");
 exports.services = {
@@ -57,7 +73,9 @@ exports.services = {
             enrich: expansion_2.companyLinkedinEnrich,
             search: b2b_2.linkedinSearch
         },
-        getEmployeesFromLinkedin: expansion_2.companyGetEmployeesFromLinkedin
+        getEmployeesFromLinkedin: expansion_2.companyGetEmployeesFromLinkedin,
+        findCareersPage: careers_2.findCareersPage,
+        scrapeCareersPage: careers_2.scrapeCareersPage
     },
     person: {
         linkedin: {
@@ -91,11 +109,19 @@ exports.services = {
     googleMaps: {
         scrape: googleMaps_2.googleMapsScrape
     },
+    ocean: {
+        search: {
+            companies: ocean_2.oceanSearchCompanies,
+            people: ocean_2.oceanSearchPeople
+        }
+    },
     builtWith: {
         lookupDomain: expansion_2.builtWithLookupDomain,
         relationships: expansion_2.builtWithRelationships,
         searchByTech: expansion_2.builtWithSearchByTech
     },
-    predictLeads: predictLeads_2.predictLeads
+    predictLeads: predictLeads_2.predictLeads,
+    integrations: integrations_2.integrations,
+    skills: skills_2.skills
 };
 exports.default = exports.services;

package/dist/integrations.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Integrations API for the orangeslice SDK.
+ *
+ * Usage:
+ *   import { integrations } from "orangeslice";
+ *
+ *   // Connect an OAuth provider (opens browser)
+ *   const hubspot = await integrations.connect("hubspot");
+ *
+ *   // List connected integrations
+ *   const { integrations: list } = await integrations.list();
+ *
+ *   // Programmatic API-key create (no browser)
+ *   await integrations.create({ provider: "instantly", apiKey: "inst_..." });
+ */
+export type IntegrationProvider = "hubspot" | "salesforce" | "attio" | "gmail" | "slack" | "instantly" | "heyreach";
+export interface Integration {
+    id: string;
+    provider: string;
+    displayName: string;
+    isActive: boolean;
+    hasApiKey: boolean;
+    hasOauthToken: boolean;
+    createdAt: string;
+    updatedAt: string;
+    scope: "account" | "spreadsheet";
+    spreadsheetId?: string | null;
+}
+export interface IntegrationListParams {
+    spreadsheetId?: string;
+    provider?: IntegrationProvider;
+}
+export interface IntegrationCreateParams {
+    provider: IntegrationProvider;
+    apiKey: string;
+    displayName?: string;
+    config?: Record<string, string>;
+    spreadsheetId?: string;
+}
+export interface IntegrationUpdateParams {
+    apiKey?: string;
+    displayName?: string;
+    isActive?: boolean;
+    config?: Record<string, string>;
+}
+export interface IntegrationConnectOptions {
+    noBrowser?: boolean;
+}
+export declare const integrations: {
+    connect: (provider: IntegrationProvider, opts?: IntegrationConnectOptions) => Promise<Integration>;
+    list: (opts?: IntegrationListParams) => Promise<{
+        integrations: Integration[];
+    }>;
+    get: (id: string) => Promise<Integration>;
+    create: (opts: IntegrationCreateParams) => Promise<Integration>;
+    update: (id: string, fields: IntegrationUpdateParams) => Promise<Integration>;
+    delete: (id: string) => Promise<{
+        success: boolean;
+    }>;
+};

package/dist/integrations.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Integrations API for the orangeslice SDK.
+ *
+ * Usage:
+ *   import { integrations } from "orangeslice";
+ *
+ *   // Connect an OAuth provider (opens browser)
+ *   const hubspot = await integrations.connect("hubspot");
+ *
+ *   // List connected integrations
+ *   const { integrations: list } = await integrations.list();
+ *
+ *   // Programmatic API-key create (no browser)
+ *   await integrations.create({ provider: "instantly", apiKey: "inst_..." });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integrations = void 0;
+const api_1 = require("./api");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const AUTH_BASE_URL = "https://www.orangeslice.ai";
+const CONNECT_POLL_TIMEOUT_MS = 600000;
+// ---------------------------------------------------------------------------
+// Browser helper (same as cli.ts)
+// ---------------------------------------------------------------------------
+function openBrowser(url) {
+    if (!process?.versions?.node) {
+        console.log(`  Open this URL in your browser:\n  ${url}\n`);
+        return;
+    }
+    try {
+        const { execFileSync } = require("child_process");
+        if (process.platform === "darwin") {
+            execFileSync("open", [url], { stdio: "ignore" });
+            return;
+        }
+        if (process.platform === "win32") {
+            execFileSync("cmd.exe", ["/c", "start", "", url], { stdio: "ignore" });
+            return;
+        }
+        execFileSync("xdg-open", [url], { stdio: "ignore" });
+    }
+    catch {
+        console.log(`  Open this URL in your browser:\n  ${url}\n`);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ---------------------------------------------------------------------------
+// Connect (device flow via Next.js)
+// ---------------------------------------------------------------------------
+async function connectIntegration(provider, opts) {
+    const startRes = await fetch(`${AUTH_BASE_URL}/api/orangeslice/integrations/connect/start`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ provider })
+    });
+    if (!startRes.ok) {
+        const data = (await startRes.json().catch(() => ({})));
+        throw new Error(`[orangeslice] integrations.connect: ${data.error || "Failed to start connect flow"}`);
+    }
+    const start = (await startRes.json());
+    if (opts?.noBrowser) {
+        console.log(`  Open this URL to connect ${provider}:\n  ${start.verificationUrl}\n`);
+    }
+    else {
+        openBrowser(start.verificationUrl);
+        console.log(`  Browser opened. Complete ${provider} authorization there, then return here.\n`);
+    }
+    const timeoutAt = Date.now() + CONNECT_POLL_TIMEOUT_MS;
+    let pollInterval = start.pollIntervalMs > 0 ? start.pollIntervalMs : 1000;
+    while (Date.now() < timeoutAt) {
+        await sleep(pollInterval);
+        const pollRes = await fetch(`${AUTH_BASE_URL}/api/orangeslice/integrations/connect/poll?deviceCode=${encodeURIComponent(start.deviceCode)}`, { method: "GET", headers: { "Content-Type": "application/json" } });
+        const data = (await pollRes.json());
+        if (data.status === "pending")
+            continue;
+        if (data.status === "approved" && data.integration) {
+            return data.integration;
+        }
+        if (data.status === "expired") {
+            throw new Error(`[orangeslice] integrations.connect: Device code expired. Please try again.`);
+        }
+        if (data.status === "consumed") {
+            throw new Error(`[orangeslice] integrations.connect: Device code already used.`);
+        }
+        if (!pollRes.ok) {
+            throw new Error(`[orangeslice] integrations.connect: ${data.error || "Polling failed"}`);
+        }
+    }
+    throw new Error(`[orangeslice] integrations.connect: Timed out waiting for authorization.`);
+}
+// ---------------------------------------------------------------------------
+// CRUD (via batch-service)
+// ---------------------------------------------------------------------------
+exports.integrations = {
+    connect: (provider, opts) => connectIntegration(provider, opts),
+    list: (opts) => (0, api_1.post)("/ctx/integrations/list", (opts ?? {})),
+    get: (id) => (0, api_1.post)("/ctx/integrations/get", { id }),
+    create: (opts) => (0, api_1.post)("/ctx/integrations/create", opts),
+    update: (id, fields) => (0, api_1.post)("/ctx/integrations/update", { id, ...fields }),
+    delete: (id) => (0, api_1.post)("/ctx/integrations/delete", { id })
+};

package/dist/ocean.d.ts

@@ -0,0 +1,160 @@
+export declare const OCEAN_OPERATION_IDS: {
+    readonly searchCompanies: "search-companies";
+    readonly searchPeople: "search-people";
+};
+export type OceanOperationId = (typeof OCEAN_OPERATION_IDS)[keyof typeof OCEAN_OPERATION_IDS];
+export interface OceanCompaniesFilters {
+    lookalikeDomains?: string[];
+    companySizes?: Array<"0-1" | "2-10" | "11-50" | "51-200" | "201-500" | "501-1000" | "1001-5000" | "5001-10000" | "10001+">;
+    countries?: string[];
+    industries?: string[];
+    ecommerce?: boolean;
+}
+export interface OceanPeopleFilters {
+    seniorities?: string[];
+    departments?: string[];
+    jobTitleKeywords?: string[];
+    countries?: string[];
+    lookalikePeopleIds?: string[];
+}
+export interface OceanCompaniesSearchParams {
+    companiesFilters?: OceanCompaniesFilters;
+    peopleFilters?: OceanPeopleFilters;
+    size?: number;
+    searchAfter?: string;
+}
+export interface OceanPhone {
+    country?: string;
+    number: string;
+    primary?: boolean;
+}
+export interface OceanMediaProfile {
+    url?: string;
+    handle?: string;
+    name?: string;
+}
+export interface OceanLocation {
+    primary?: boolean;
+    latitude?: number;
+    longitude?: number;
+    country?: string;
+    locality?: string;
+    region?: string;
+    postalCode?: string;
+    streetAddress?: string;
+    state?: string;
+}
+export interface OceanDepartmentSize {
+    department: string;
+    size: number;
+}
+export interface OceanHeadcountGrowth {
+    threeMonths?: number;
+    threeMonthsPercentage?: number;
+    sixMonths?: number;
+    sixMonthsPercentage?: number;
+    twelveMonths?: number;
+    twelveMonthsPercentage?: number;
+}
+export interface OceanCompanyResult {
+    domain: string;
+    name?: string;
+    legalName?: string;
+    description?: string;
+    countries?: string[];
+    primaryCountry?: string;
+    companySize?: string;
+    industryCategories?: string[];
+    industries?: string[];
+    linkedinIndustry?: string;
+    ecommerce?: boolean;
+    keywords?: string[];
+    employeeCountOcean?: number;
+    employeeCountLinkedin?: number;
+    revenue?: string;
+    yearFounded?: number;
+    emails?: string[];
+    phones?: OceanPhone[];
+    logo?: string;
+    technologies?: string[];
+    technologyCategories?: string[];
+    rootUrl?: string;
+    medias?: Record<string, OceanMediaProfile>;
+    locations?: OceanLocation[];
+    departmentSizes?: OceanDepartmentSize[];
+    headcountGrowth?: OceanHeadcountGrowth;
+    updatedAt?: string;
+}
+export interface OceanCompanyMatch {
+    company: OceanCompanyResult;
+    relevance?: string;
+}
+export interface OceanCompaniesSearchResponse {
+    detail?: string;
+    total: number;
+    searchAfter?: string;
+    companies: OceanCompanyMatch[];
+    redirectMap?: Record<string, string>;
+}
+export interface OceanPersonExperience {
+    dateFrom?: string;
+    dateTo?: string;
+    description?: string;
+    domain?: string;
+    jobTitle?: string;
+}
+export interface OceanContactField {
+    address?: string;
+    status?: string;
+}
+export interface OceanPhoneField {
+    numbers?: string[];
+    status?: string;
+}
+export interface OceanPersonCompanySnapshot {
+    companySize?: string;
+    logo?: string;
+    name?: string;
+}
+export interface OceanPersonResult {
+    id: string;
+    domain?: string;
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    country?: string;
+    state?: string;
+    location?: string;
+    linkedinUrl?: string;
+    seniorities?: string[];
+    departments?: string[];
+    photo?: string;
+    jobTitle?: string;
+    jobTitleEnglish?: string;
+    currentJobDescription?: string;
+    experiences?: OceanPersonExperience[];
+    summary?: string;
+    skills?: string[];
+    phone?: OceanPhoneField;
+    email?: OceanContactField;
+    updatedAt?: string;
+    company?: OceanPersonCompanySnapshot;
+}
+export interface OceanPeopleSearchParams {
+    companiesFilters?: OceanCompaniesFilters;
+    peopleFilters?: OceanPeopleFilters;
+    size?: number;
+    from?: number;
+    searchAfter?: string;
+    enableEmailSearch?: boolean;
+    enablePhoneSearch?: boolean;
+}
+export interface OceanPeopleSearchResponse {
+    total: number;
+    searchAfter?: string;
+    people: OceanPersonResult[];
+    redirectMap?: Record<string, string>;
+}
+export declare function executeOcean<T = unknown>(operationId: OceanOperationId, params?: Record<string, unknown>): Promise<T>;
+export declare function oceanSearchCompanies(params: OceanCompaniesSearchParams): Promise<OceanCompaniesSearchResponse>;
+export declare function oceanSearchPeople(params: OceanPeopleSearchParams): Promise<OceanPeopleSearchResponse>;

package/dist/ocean.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OCEAN_OPERATION_IDS = void 0;
+exports.executeOcean = executeOcean;
+exports.oceanSearchCompanies = oceanSearchCompanies;
+exports.oceanSearchPeople = oceanSearchPeople;
+const api_1 = require("./api");
+exports.OCEAN_OPERATION_IDS = {
+    searchCompanies: "search-companies",
+    searchPeople: "search-people"
+};
+async function executeOcean(operationId, params) {
+    return (0, api_1.post)("/execute/oceanio", {
+        operationId,
+        params: params ?? {}
+    });
+}
+async function oceanSearchCompanies(params) {
+    return executeOcean(exports.OCEAN_OPERATION_IDS.searchCompanies, params);
+}
+async function oceanSearchPeople(params) {
+    return executeOcean(exports.OCEAN_OPERATION_IDS.searchPeople, params);
+}

package/dist/skills.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Knowledge Skills API for the orangeslice SDK.
+ *
+ * Usage:
+ *   import { skills } from "orangeslice";
+ *
+ *   // Create a skill
+ *   const skill = await skills.create({
+ *     title: "CRM Mapping",
+ *     description: "Maps company fields to HubSpot properties",
+ *     content: "When pushing to HubSpot, map ...",
+ *   });
+ *
+ *   // List all skills
+ *   const { skills: list } = await skills.list();
+ *
+ *   // Update a skill
+ *   await skills.update(skill.id, { autoInject: true });
+ */
+export interface Skill {
+    id: string;
+    title: string;
+    description: string;
+    content: string;
+    autoInject: boolean;
+    createdAt: string;
+    updatedAt: string;
+    scope: "account" | "spreadsheet";
+    spreadsheetId?: string | null;
+}
+export interface SkillListParams {
+    spreadsheetId?: string;
+}
+export interface SkillCreateParams {
+    title: string;
+    description: string;
+    content: string;
+    autoInject?: boolean;
+    spreadsheetId?: string;
+}
+export interface SkillUpdateParams {
+    title?: string;
+    description?: string;
+    content?: string;
+    autoInject?: boolean;
+}
+export declare const skills: {
+    list: (opts?: SkillListParams) => Promise<{
+        skills: Skill[];
+    }>;
+    get: (id: string) => Promise<Skill>;
+    create: (opts: SkillCreateParams) => Promise<Skill>;
+    update: (id: string, fields: SkillUpdateParams) => Promise<Skill>;
+    delete: (id: string) => Promise<{
+        success: boolean;
+    }>;
+};