@myapihq/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,50 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflow = exports.webhook = exports.storage = exports.pixel = exports.image = exports.funnel = exports.email = exports.domain = exports.hq = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./client"), exports);
+exports.hq = __importStar(require("./hq"));
+exports.domain = __importStar(require("./domain"));
+exports.email = __importStar(require("./email"));
+exports.funnel = __importStar(require("./funnel"));
+exports.image = __importStar(require("./image"));
+exports.pixel = __importStar(require("./pixel"));
+exports.storage = __importStar(require("./storage"));
+exports.webhook = __importStar(require("./webhook"));
+exports.workflow = __importStar(require("./workflow"));

package/dist/pixel.d.ts

@@ -0,0 +1,65 @@
+export interface InteractionsResponse {
+    interactions: (Visit | PixelEvent)[];
+    total_visits: number;
+    total_events: number;
+    limit: number;
+    offset: number;
+}
+export interface Visit {
+    type: 'visit';
+    pixel_id: string;
+    from_url: string;
+    to_url: string;
+    ts: string;
+}
+export interface PixelEvent {
+    type: 'event';
+    pixel_id: string;
+    event_type: 'sent' | 'open' | 'click' | 'page_visit';
+    url?: string;
+    campaign_id?: string;
+    ts: string;
+}
+export declare function getInteractions(apiKey: string, params: {
+    website?: string;
+    domain?: string;
+    campaign_id?: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<InteractionsResponse>;
+export declare function getVisits(apiKey: string, params: {
+    website: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    visits: Visit[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare function getEvents(apiKey: string, params: {
+    campaign_id?: string;
+    domain?: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    events: PixelEvent[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare function getIdentity(apiKey: string, pixelId: string): Promise<{
+    uuid: string;
+    is_resolved: boolean;
+    nodes: Record<string, {
+        type: string;
+        probability: number;
+    }>;
+    latency_ms: number;
+}>;

package/dist/pixel.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInteractions = getInteractions;
+exports.getVisits = getVisits;
+exports.getEvents = getEvents;
+exports.getIdentity = getIdentity;
+const client_1 = require("./client");
+const BASE_URL = 'https://api.mypixelapi.com';
+async function getInteractions(apiKey, params) {
+    const qs = new URLSearchParams();
+    for (const [key, val] of Object.entries(params)) {
+        if (val !== undefined && val !== null) {
+            qs.set(key, String(val));
+        }
+    }
+    const queryString = qs.toString();
+    const url = `${BASE_URL}/pixel/interactions${queryString ? `?${queryString}` : ''}`;
+    return (0, client_1.request)('GET', url, apiKey);
+}
+async function getVisits(apiKey, params) {
+    const qs = new URLSearchParams();
+    for (const [key, val] of Object.entries(params)) {
+        if (val !== undefined && val !== null) {
+            qs.set(key, String(val));
+        }
+    }
+    const queryString = qs.toString();
+    const url = `${BASE_URL}/pixel/visits${queryString ? `?${queryString}` : ''}`;
+    return (0, client_1.request)('GET', url, apiKey);
+}
+async function getEvents(apiKey, params) {
+    const qs = new URLSearchParams();
+    for (const [key, val] of Object.entries(params)) {
+        if (val !== undefined && val !== null) {
+            qs.set(key, String(val));
+        }
+    }
+    const queryString = qs.toString();
+    const url = `${BASE_URL}/pixel/events${queryString ? `?${queryString}` : ''}`;
+    return (0, client_1.request)('GET', url, apiKey);
+}
+async function getIdentity(apiKey, pixelId) {
+    return (0, client_1.request)('GET', `${BASE_URL}/pixel/identity/${encodeURIComponent(pixelId)}`, apiKey);
+}

package/dist/storage.d.ts

@@ -0,0 +1,10 @@
+export interface Asset {
+    asset_id: string;
+    url: string;
+    name: string;
+    created_at: string;
+}
+export declare function ingestAsset(apiKey: string, url: string, name?: string): Promise<Asset>;
+export declare function uploadAsset(apiKey: string, file: Blob | Buffer, contentType: 'image/jpeg' | 'image/png', name?: string): Promise<Asset>;
+export declare function listAssets(apiKey: string): Promise<Asset[]>;
+export declare function deleteAsset(apiKey: string, assetId: string): Promise<void>;

package/dist/storage.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ingestAsset = ingestAsset;
+exports.uploadAsset = uploadAsset;
+exports.listAssets = listAssets;
+exports.deleteAsset = deleteAsset;
+const client_1 = require("./client");
+const BASE_URL = 'https://api.mystorageapi.com';
+async function ingestAsset(apiKey, url, name) {
+    return (0, client_1.request)('POST', `${BASE_URL}/hq/assets/ingest`, apiKey, { url, name });
+}
+async function uploadAsset(apiKey, file, contentType, name) {
+    const headers = {
+        'Authorization': `Bearer ${apiKey}`
+    };
+    const formData = new FormData();
+    formData.append('file', new Blob([file], { type: contentType }));
+    if (name) {
+        formData.append('name', name);
+    }
+    const response = await fetch(`${BASE_URL}/hq/assets/upload`, {
+        method: 'POST',
+        headers,
+        body: formData
+    });
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch {
+        throw new client_1.MyApiError('invalid_json_response', response.status);
+    }
+    if (!response.ok) {
+        const code = result?.error || 'unknown_error';
+        throw new client_1.MyApiError(code, response.status);
+    }
+    const apiResponse = result;
+    if (!apiResponse.success) {
+        throw new client_1.MyApiError(apiResponse.error || 'unknown_error', response.status);
+    }
+    return apiResponse.data;
+}
+async function listAssets(apiKey) {
+    return (0, client_1.request)('GET', `${BASE_URL}/hq/assets`, apiKey);
+}
+async function deleteAsset(apiKey, assetId) {
+    return (0, client_1.request)('DELETE', `${BASE_URL}/hq/assets/${encodeURIComponent(assetId)}`, apiKey);
+}

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+export interface ApiResponse<T> {
+    success: boolean;
+    data: T | null;
+    error: string | null;
+    meta: {
+        request_id: string;
+        latency_ms: number;
+        service: string;
+        version: string;
+    };
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/webhook.d.ts

@@ -0,0 +1,20 @@
+export interface WebhookEndpoint {
+    id: string;
+    org_id: string;
+    name: string;
+    slug: string;
+    inbound_url: string;
+    created_at: string;
+}
+export interface Delivery {
+    id: string;
+    endpoint_id: string;
+    payload: unknown;
+    headers: Record<string, string>;
+    status: string;
+    created_at: string;
+}
+export declare function createEndpoint(apiKey: string, orgId: string, name: string, description?: string): Promise<WebhookEndpoint>;
+export declare function listEndpoints(apiKey: string): Promise<WebhookEndpoint[]>;
+export declare function deleteEndpoint(apiKey: string, endpointId: string): Promise<void>;
+export declare function getDelivery(apiKey: string, deliveryId: string): Promise<Delivery>;

package/dist/webhook.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEndpoint = createEndpoint;
+exports.listEndpoints = listEndpoints;
+exports.deleteEndpoint = deleteEndpoint;
+exports.getDelivery = getDelivery;
+const client_1 = require("./client");
+const BASE_URL = 'https://api.mywebhookapi.com';
+async function createEndpoint(apiKey, orgId, name, description) {
+    return (0, client_1.request)('POST', `${BASE_URL}/webhook/endpoints`, apiKey, { org_id: orgId, name, description });
+}
+async function listEndpoints(apiKey) {
+    return (0, client_1.request)('GET', `${BASE_URL}/webhook/endpoints`, apiKey);
+}
+async function deleteEndpoint(apiKey, endpointId) {
+    return (0, client_1.request)('DELETE', `${BASE_URL}/webhook/endpoints/${encodeURIComponent(endpointId)}`, apiKey);
+}
+async function getDelivery(apiKey, deliveryId) {
+    return (0, client_1.request)('GET', `${BASE_URL}/webhook/deliveries/${encodeURIComponent(deliveryId)}`, apiKey);
+}

package/dist/workflow.d.ts

@@ -0,0 +1,56 @@
+export type WorkflowStep = {
+    type: 'send_email';
+    from: string;
+    to: string;
+    subject: string;
+    template_id?: string;
+    html?: string;
+} | {
+    type: 'slack_message';
+    webhook_url: string;
+    text: string;
+};
+export interface Workflow {
+    id: string;
+    org_id: string;
+    name: string;
+    status: 'enabled' | 'disabled';
+    trigger_config: {
+        endpoint_id: string;
+    };
+    steps: WorkflowStep[];
+    created_at: string;
+}
+export interface WorkflowRun {
+    id: string;
+    workflow_id: string;
+    trigger_payload: unknown;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    error?: string;
+    attempt: number;
+    started_at: string;
+    finished_at?: string;
+    created_at: string;
+}
+export declare function createWorkflow(apiKey: string, payload: {
+    org_id: string;
+    name: string;
+    trigger_config: {
+        endpoint_id: string;
+    };
+    steps: WorkflowStep[];
+}): Promise<Workflow>;
+export declare function listWorkflows(apiKey: string): Promise<Workflow[]>;
+export declare function getWorkflow(apiKey: string, workflowId: string): Promise<Workflow>;
+export declare function updateWorkflow(apiKey: string, workflowId: string, payload: {
+    name?: string;
+    trigger_config?: {
+        endpoint_id: string;
+    };
+    steps?: WorkflowStep[];
+}): Promise<Workflow>;
+export declare function enableWorkflow(apiKey: string, workflowId: string): Promise<void>;
+export declare function disableWorkflow(apiKey: string, workflowId: string): Promise<void>;
+export declare function deleteWorkflow(apiKey: string, workflowId: string): Promise<void>;
+export declare function listWorkflowRuns(apiKey: string, workflowId: string): Promise<WorkflowRun[]>;
+export declare function getWorkflowRun(apiKey: string, runId: string): Promise<WorkflowRun>;

package/dist/workflow.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkflow = createWorkflow;
+exports.listWorkflows = listWorkflows;
+exports.getWorkflow = getWorkflow;
+exports.updateWorkflow = updateWorkflow;
+exports.enableWorkflow = enableWorkflow;
+exports.disableWorkflow = disableWorkflow;
+exports.deleteWorkflow = deleteWorkflow;
+exports.listWorkflowRuns = listWorkflowRuns;
+exports.getWorkflowRun = getWorkflowRun;
+const client_1 = require("./client");
+const BASE_URL = 'https://api.myworkflowapi.com';
+async function createWorkflow(apiKey, payload) {
+    return (0, client_1.request)('POST', `${BASE_URL}/workflow/workflows`, apiKey, payload);
+}
+async function listWorkflows(apiKey) {
+    return (0, client_1.request)('GET', `${BASE_URL}/workflow/workflows`, apiKey);
+}
+async function getWorkflow(apiKey, workflowId) {
+    return (0, client_1.request)('GET', `${BASE_URL}/workflow/workflows/${encodeURIComponent(workflowId)}`, apiKey);
+}
+async function updateWorkflow(apiKey, workflowId, payload) {
+    return (0, client_1.request)('PATCH', `${BASE_URL}/workflow/workflows/${encodeURIComponent(workflowId)}`, apiKey, payload);
+}
+async function enableWorkflow(apiKey, workflowId) {
+    return (0, client_1.request)('POST', `${BASE_URL}/workflow/workflows/${encodeURIComponent(workflowId)}/enable`, apiKey);
+}
+async function disableWorkflow(apiKey, workflowId) {
+    return (0, client_1.request)('POST', `${BASE_URL}/workflow/workflows/${encodeURIComponent(workflowId)}/disable`, apiKey);
+}
+async function deleteWorkflow(apiKey, workflowId) {
+    return (0, client_1.request)('DELETE', `${BASE_URL}/workflow/workflows/${encodeURIComponent(workflowId)}`, apiKey);
+}
+async function listWorkflowRuns(apiKey, workflowId) {
+    return (0, client_1.request)('GET', `${BASE_URL}/workflow/workflows/${encodeURIComponent(workflowId)}/runs`, apiKey);
+}
+async function getWorkflowRun(apiKey, runId) {
+    return (0, client_1.request)('GET', `${BASE_URL}/workflow/runs/${encodeURIComponent(runId)}`, apiKey);
+}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@myapihq/sdk",
+  "version": "1.0.0",
+  "description": "TypeScript SDK for the MyAPI ecosystem",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "typescript": "^5.4.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,59 @@
+import { ApiResponse } from './types';
+
+export class MyApiError extends Error {
+  constructor(public code: string, public status: number) {
+    super(code);
+    this.name = 'MyApiError';
+  }
+}
+
+export async function request<T>(
+  method: string,
+  url: string,
+  apiKey?: string,
+  body?: unknown
+): Promise<T> {
+  const headers: Record<string, string> = {};
+  
+  if (apiKey) {
+    headers['Authorization'] = `Bearer ${apiKey}`;
+  }
+
+  if (body !== undefined) {
+    headers['Content-Type'] = 'application/json';
+  }
+
+  const options: RequestInit = {
+    method,
+    headers,
+  };
+
+  if (body !== undefined) {
+    options.body = JSON.stringify(body);
+  }
+
+  const response = await fetch(url, options);
+
+  if (response.status === 204) {
+    return undefined as T;
+  }
+  
+  let result: any;
+  try {
+    result = await response.json();
+  } catch {
+    throw new MyApiError('invalid_json_response', response.status);
+  }
+
+  if (!response.ok) {
+    const code = result?.error || 'unknown_error';
+    throw new MyApiError(code, response.status);
+  }
+
+  const apiResponse = result as ApiResponse<T>;
+  if (!apiResponse.success) {
+    throw new MyApiError(apiResponse.error || 'unknown_error', response.status);
+  }
+
+  return apiResponse.data as T;
+}

package/src/domain.ts

@@ -0,0 +1,54 @@
+import { request } from './client';
+
+const BASE_URL = 'https://api.mydomainapi.com';
+
+export interface DomainRecord {
+  domain: string;
+  status: string;
+  expires_at?: string;
+  created_at: string;
+}
+
+export interface DomainSettings {
+  domain: string;
+  security_level: string;
+  browser_check: string;
+  ai_bots_protection: string;
+  is_robots_txt_managed: boolean;
+}
+
+export async function checkDomain(apiKey: string, domain: string): Promise<{ available: boolean; price_cents: number }> {
+  return request('GET', `${BASE_URL}/domain/check/${encodeURIComponent(domain)}`, apiKey);
+}
+
+export async function registerDomain(apiKey: string, domain: string, years?: number): Promise<DomainRecord> {
+  return request('POST', `${BASE_URL}/domain/register`, apiKey, { domain, years });
+}
+
+export async function importDomain(apiKey: string, payload: { domain: string; namecheap_api_user?: string; namecheap_api_key?: string; }): Promise<DomainRecord> {
+  return request('POST', `${BASE_URL}/domain/import`, apiKey, payload);
+}
+
+export async function listDomains(apiKey: string): Promise<DomainRecord[]> {
+  return request('GET', `${BASE_URL}/domain/list/me`, apiKey);
+}
+
+export async function getDomainStatus(apiKey: string, domain: string): Promise<DomainRecord> {
+  return request('GET', `${BASE_URL}/domain/status/${encodeURIComponent(domain)}`, apiKey);
+}
+
+export async function renewDomain(apiKey: string, domain: string, years?: number): Promise<DomainRecord> {
+  return request('POST', `${BASE_URL}/domain/renew/${encodeURIComponent(domain)}`, apiKey, { years });
+}
+
+export async function getDomainSettings(apiKey: string, domain: string): Promise<DomainSettings> {
+  return request('GET', `${BASE_URL}/domain/settings/${encodeURIComponent(domain)}`, apiKey);
+}
+
+export async function updateDomainSettings(apiKey: string, domain: string, payload: {
+  security_level?: 'essentially_off' | 'medium' | 'high' | 'under_attack';
+  browser_check?: 'on' | 'off';
+  purge_cache?: boolean;
+}): Promise<DomainSettings> {
+  return request('POST', `${BASE_URL}/domain/settings/${encodeURIComponent(domain)}`, apiKey, payload);
+}

package/src/email.ts

@@ -0,0 +1,102 @@
+import { request } from './client';
+
+const BASE_URL = 'https://api.myemailapi.com';
+
+export interface EmailMessage { message_id: string; from: string; subject: string; body?: string; received_at: string }
+export interface EmailTemplate { id: string; name: string; subject: string; preview_url: string; created_at: string; updated_at: string }
+export interface Campaign { id: string; name: string; status: string; template_id: string; from_address: string; rate_per_minute: number; per_hour_limit: number; created_at: string }
+export interface CampaignStats {
+  campaign: Campaign;
+  validation: { total: number; valid: number; invalid: number; pending: number; list_status: string };
+  dispatch: { sent: number; remaining: number; sent_this_hour: number; hour_limit: number; last_dispatch_at: string };
+  engagement: { sent: number; opens: number; clicks: number; page_visits: number };
+}
+
+export async function createMailbox(apiKey: string, domain: string, username: string): Promise<{ address: string; created_at: string }> {
+  return request('POST', `${BASE_URL}/email/mailbox/create`, apiKey, { domain, username });
+}
+export async function listMailboxes(apiKey: string): Promise<{ address: string; created_at: string }[]> {
+  return request('GET', `${BASE_URL}/email/mailbox/list/me`, apiKey);
+}
+export async function activateSending(apiKey: string, address: string): Promise<{ status: string }> {
+  return request('POST', `${BASE_URL}/email/sending/activate`, apiKey, { address });
+}
+
+export async function sendEmail(apiKey: string, payload: { from: string; to: string[]; subject: string; html?: string; text?: string; }): Promise<{ message_id: string }> {
+  return request('POST', `${BASE_URL}/email/send`, apiKey, payload);
+}
+export async function getEmailStatus(apiKey: string, messageId: string): Promise<{ status: string; delivered_at?: string }> {
+  return request('GET', `${BASE_URL}/email/status/${encodeURIComponent(messageId)}`, apiKey);
+}
+export async function getInbox(apiKey: string, address: string): Promise<EmailMessage[]> {
+  return request('GET', `${BASE_URL}/email/inbox/${encodeURIComponent(address)}`, apiKey);
+}
+export async function getMessage(apiKey: string, messageId: string, address: string): Promise<EmailMessage> {
+  return request('GET', `${BASE_URL}/email/message/${encodeURIComponent(messageId)}?address=${encodeURIComponent(address)}`, apiKey);
+}
+
+export async function startWarmup(apiKey: string, address: string): Promise<{ warmup_status: string }> {
+  return request('POST', `${BASE_URL}/email/warmup/start`, apiKey, { address });
+}
+export async function pauseWarmup(apiKey: string, address: string): Promise<void> {
+  return request('POST', `${BASE_URL}/email/warmup/pause`, apiKey, { address });
+}
+export async function resumeWarmup(apiKey: string, address: string): Promise<void> {
+  return request('POST', `${BASE_URL}/email/warmup/resume`, apiKey, { address });
+}
+export async function stopWarmup(apiKey: string, address: string): Promise<void> {
+  return request('POST', `${BASE_URL}/email/warmup/stop`, apiKey, { address });
+}
+export async function getWarmupStats(apiKey: string, address: string): Promise<{ sent: number; landed_inbox: number; landed_spam: number; health_score: number }> {
+  return request('GET', `${BASE_URL}/email/warmup/stats/${encodeURIComponent(address)}`, apiKey);
+}
+
+export async function generateTemplate(apiKey: string, payload: { org_id: string; prompt: string; name: string; }): Promise<{ job_id: string; template_id: string; status: string; preview_url: string }> {
+  return request('POST', `${BASE_URL}/email/templates/generate`, apiKey, payload);
+}
+export async function getTemplateJobStatus(apiKey: string, jobId: string): Promise<{ status: 'processing' | 'completed' | 'failed'; template_id: string; result?: { subject: string; preview_url: string } }> {
+  return request('GET', `${BASE_URL}/email/template-jobs/${encodeURIComponent(jobId)}`, apiKey);
+}
+export async function editTemplate(apiKey: string, templateId: string, prompt: string): Promise<{ template_id: string; preview_url: string }> {
+  return request('POST', `${BASE_URL}/email/templates/${encodeURIComponent(templateId)}/edit`, apiKey, { prompt });
+}
+export async function sendTestEmail(apiKey: string, templateId: string, to: string): Promise<{ ok: boolean; message_id: string }> {
+  return request('POST', `${BASE_URL}/email/templates/${encodeURIComponent(templateId)}/send-test`, apiKey, { to });
+}
+export async function listTemplates(apiKey: string): Promise<EmailTemplate[]> {
+  return request('GET', `${BASE_URL}/email/templates`, apiKey);
+}
+export async function deleteTemplate(apiKey: string, templateId: string): Promise<void> {
+  return request('DELETE', `${BASE_URL}/email/templates/${encodeURIComponent(templateId)}`, apiKey);
+}
+
+export async function createCampaign(apiKey: string, payload: { name: string; template_id: string; from_address: string; rate_per_minute?: number; per_hour_limit?: number; }): Promise<Campaign> {
+  return request('POST', `${BASE_URL}/email/campaigns`, apiKey, payload);
+}
+export async function uploadContactList(apiKey: string, campaignId: string, emails: string[]): Promise<{ list_id: string; total: number; status: string }> {
+  return request('POST', `${BASE_URL}/email/campaigns/${encodeURIComponent(campaignId)}/contacts/upload-list`, apiKey, { emails });
+}
+export async function getContactUploadStatus(apiKey: string, campaignId: string): Promise<{ upload_status: 'ready' | 'validating' | 'failed'; total: number; valid_count: number; invalid_count: number }> {
+  return request('GET', `${BASE_URL}/email/campaigns/${encodeURIComponent(campaignId)}/contacts/status`, apiKey);
+}
+export async function startCampaign(apiKey: string, campaignId: string): Promise<{ status: string }> {
+  return request('POST', `${BASE_URL}/email/campaigns/${encodeURIComponent(campaignId)}/start`, apiKey);
+}
+export async function pauseCampaign(apiKey: string, campaignId: string): Promise<void> {
+  return request('POST', `${BASE_URL}/email/campaigns/${encodeURIComponent(campaignId)}/pause`, apiKey);
+}
+export async function resumeCampaign(apiKey: string, campaignId: string): Promise<void> {
+  return request('POST', `${BASE_URL}/email/campaigns/${encodeURIComponent(campaignId)}/resume`, apiKey);
+}
+export async function getCampaignStats(apiKey: string, campaignId: string): Promise<CampaignStats> {
+  return request('GET', `${BASE_URL}/email/campaigns/${encodeURIComponent(campaignId)}/stats`, apiKey);
+}
+export async function listCampaigns(apiKey: string): Promise<Campaign[]> {
+  return request('GET', `${BASE_URL}/email/campaigns`, apiKey);
+}
+export async function getCampaign(apiKey: string, campaignId: string): Promise<Campaign> {
+  return request('GET', `${BASE_URL}/email/campaigns/${encodeURIComponent(campaignId)}`, apiKey);
+}
+export async function updateCampaign(apiKey: string, campaignId: string, payload: { name?: string; per_day_limit?: number }): Promise<Campaign> {
+  return request('PATCH', `${BASE_URL}/email/campaigns/${encodeURIComponent(campaignId)}`, apiKey, payload);
+}

package/src/funnel.ts

@@ -0,0 +1,29 @@
+import { request } from './client';
+
+const BASE_URL = 'https://api.myfunnelapi.com';
+
+export interface Funnel { id: string; org_id: string; domain: string; created_at: string }
+export interface VerifyResult {
+  pages?: Array<{ slug: string; tests: VerifyTest[] }>;
+  tests?: VerifyTest[];
+}
+export interface VerifyTest { type: 'link' | 'webhook'; url: string; passed: boolean; details: string }
+
+export async function createFunnel(apiKey: string, orgId: string, domain: string): Promise<Funnel> {
+  return request('POST', `${BASE_URL}/funnel/funnels/create-raw`, apiKey, { org_id: orgId, domain });
+}
+export async function pushPage(apiKey: string, funnelId: string, slug: string, html: string): Promise<{ status: string; key: string }> {
+  return request('POST', `${BASE_URL}/funnel/funnels/${encodeURIComponent(funnelId)}/push-page`, apiKey, { slug, html });
+}
+export async function verifyFunnel(apiKey: string, funnelId: string, opts?: { html?: string; slug?: string }): Promise<VerifyResult> {
+  return request('POST', `${BASE_URL}/funnel/funnels/${encodeURIComponent(funnelId)}/verify`, apiKey, opts || {});
+}
+export async function listFunnels(apiKey: string): Promise<Funnel[]> {
+  return request('GET', `${BASE_URL}/funnel/funnels`, apiKey);
+}
+export async function getFunnel(apiKey: string, funnelId: string): Promise<Funnel> {
+  return request('GET', `${BASE_URL}/funnel/funnels/${encodeURIComponent(funnelId)}`, apiKey);
+}
+export async function deleteFunnel(apiKey: string, funnelId: string): Promise<void> {
+  return request('DELETE', `${BASE_URL}/funnel/funnels/${encodeURIComponent(funnelId)}`, apiKey);
+}