@profullstack/coinpay 0.17.0 → 0.19.0

package/src/contractors.d.ts

@@ -0,0 +1,124 @@
+import type { CoinPayClient } from './client.js';
+
+export interface Contractor {
+  id: string;
+  business_id: string;
+  name: string;
+  email: string;
+  country: string | null;
+  job_title: string | null;
+  status: 'invited' | 'active' | 'offboarded';
+  payout_currency: string | null;
+  payout_wallet: string | null;
+  payout_wallet_changed_at: string | null;
+  tax_form: 'W9' | 'W8BEN' | 'W8BENE' | null;
+  tax_status: 'missing' | 'submitted' | 'verified';
+  tax_legal_name: string | null;
+  tax_id_last4: string | null;
+  pending_approvals?: number;
+}
+
+export interface ContractorMilestone {
+  id: string;
+  contract_id: string;
+  title: string;
+  amount: string;
+  due_date: string | null;
+  position: number;
+  status: 'pending' | 'submitted' | 'approved' | 'paid';
+}
+
+export interface ContractorContract {
+  id: string;
+  contractor_id: string;
+  title: string;
+  scope: string | null;
+  kind: 'fixed' | 'hourly' | 'milestone';
+  rate: string | null;
+  frequency: 'weekly' | 'biweekly' | 'semimonthly' | 'monthly' | null;
+  start_date: string;
+  end_date: string | null;
+  next_pay_date: string | null;
+  status: 'draft' | 'sent' | 'active' | 'ended';
+  contractor_milestones?: ContractorMilestone[];
+}
+
+export interface ContractorWorkItem {
+  id: string;
+  contractor_id: string;
+  contract_id: string;
+  kind: 'hours' | 'milestone' | 'expense' | 'bonus' | 'fixed';
+  description: string;
+  work_date: string;
+  minutes: number | null;
+  amount: string;
+  status: 'submitted' | 'approved' | 'rejected' | 'paid';
+  review_note: string | null;
+}
+
+export interface PayRun {
+  id: string;
+  business_id: string;
+  number: number;
+  pay_date: string;
+  status: 'draft' | 'processing' | 'paid' | 'partially_paid';
+  total: string;
+  auto_drafted: boolean;
+  paid_at: string | null;
+  contractors?: number;
+  paid?: number;
+}
+
+export interface PayRunItem {
+  id: string;
+  contractor_id: string;
+  amount: string;
+  status: 'pending' | 'processing' | 'paid' | 'failed' | 'indeterminate';
+  method: 'wallet' | 'manual' | null;
+  tx_hash: string | null;
+  error: string | null;
+  invoice_number: string;
+  warnings?: string[];
+  can_send_from_wallet?: boolean;
+}
+
+export interface PayOutcome {
+  item_id: string;
+  contractor: string;
+  status: string;
+  tx_hash?: string | null;
+  error?: string;
+}
+
+export function listContractors(client: CoinPayClient, options?: { businessId?: string; includeOffboarded?: boolean }): Promise<Contractor[]>;
+export function getContractor(client: CoinPayClient, contractorId: string): Promise<{ contractor: Contractor; contracts: ContractorContract[]; work_items: ContractorWorkItem[]; payments: PayRunItem[] }>;
+export function addContractor(client: CoinPayClient, input: { businessId?: string; name: string; email: string; country?: string; jobTitle?: string; sendInvite?: boolean }): Promise<{ contractor: Contractor; portal_url: string }>;
+export function createContractorPortalLink(client: CoinPayClient, contractorId: string, options?: { sendEmail?: boolean }): Promise<string>;
+export function offboardContractor(client: CoinPayClient, contractorId: string): Promise<{ success: boolean }>;
+export function createContract(
+  client: CoinPayClient,
+  contractorId: string,
+  input: {
+    title: string;
+    kind: 'fixed' | 'hourly' | 'milestone';
+    scope?: string;
+    rate?: number;
+    frequency?: 'weekly' | 'biweekly' | 'semimonthly' | 'monthly';
+    startDate?: string;
+    endDate?: string;
+    firstPayDate?: string;
+    milestones?: { title: string; amount: number; due_date?: string }[];
+  }
+): Promise<ContractorContract>;
+export function sendContract(client: CoinPayClient, contractId: string, input: { signature: string }): Promise<ContractorContract>;
+export function endContract(client: CoinPayClient, contractId: string, input?: { reason?: string; endDate?: string }): Promise<ContractorContract>;
+export function listWorkItems(client: CoinPayClient, options?: { businessId?: string; status?: string; contractorId?: string }): Promise<ContractorWorkItem[]>;
+export function reviewWorkItem(client: CoinPayClient, workItemId: string, input: { action: 'approve' | 'reject'; note?: string }): Promise<ContractorWorkItem>;
+export function addContractorPayment(client: CoinPayClient, input: { businessId?: string; contractId: string; kind: 'bonus' | 'expense'; amount: number; description: string }): Promise<ContractorWorkItem>;
+export function listPayRuns(client: CoinPayClient, options?: { businessId?: string }): Promise<PayRun[]>;
+export function getPayRun(client: CoinPayClient, payRunId: string): Promise<{ pay_run: PayRun; items: PayRunItem[]; sendable_coins: string[] }>;
+export function createPayRun(client: CoinPayClient, options?: { businessId?: string; payDate?: string }): Promise<PayRun>;
+export function deletePayRun(client: CoinPayClient, payRunId: string): Promise<{ success: boolean }>;
+export function payPayRun(client: CoinPayClient, payRunId: string, options?: { itemIds?: string[] }): Promise<{ success: boolean; pay_run: PayRun; outcomes: PayOutcome[] }>;
+export function recordPayRunPayments(client: CoinPayClient, payRunId: string, payments: { itemId: string; txHash: string }[]): Promise<{ success: boolean; pay_run: PayRun; outcomes: PayOutcome[] }>;
+export function get1099Summary(client: CoinPayClient, options?: { businessId?: string; year?: number }): Promise<{ year: number; threshold: number; contractors: { contractor_id: string; name: string; tax_form: string | null; total_paid: number; needs_1099_nec: boolean; missing_w9: boolean }[] }>;

package/src/contractors.js

@@ -0,0 +1,135 @@
+/**
+ * Contractors and pay runs: invite contractors, contract with them, approve the
+ * work they submit and pay the whole team in crypto.
+ *
+ * An API key is locked to its own business, so `businessId` is optional when
+ * the client was created with one. Paying a run needs a signed-in owner
+ * (`coinpay login`), never an API key.
+ */
+
+const q = (params) => {
+  const entries = Object.entries(params).filter(([, v]) => v !== undefined && v !== null && v !== '');
+  return entries.length ? '?' + new URLSearchParams(entries.map(([k, v]) => [k, String(v)])).toString() : '';
+};
+const json = (method, body) => ({ method, body: JSON.stringify(body) });
+const id = (v) => encodeURIComponent(v);
+
+export async function listContractors(client, { businessId, includeOffboarded } = {}) {
+  const data = await client.request('/contractors' + q({ business_id: businessId, include_offboarded: includeOffboarded ? 'true' : undefined }));
+  return data.contractors ?? [];
+}
+
+/** A contractor with contracts (and milestones), work lines and payments. */
+export async function getContractor(client, contractorId) {
+  return client.request('/contractors/' + id(contractorId));
+}
+
+/** Invite a contractor. They are emailed a portal link unless sendInvite is false. */
+export async function addContractor(client, { businessId, name, email, country, jobTitle, sendInvite }) {
+  const body = { name, email };
+  if (businessId) body.business_id = businessId;
+  if (country) body.country = country;
+  if (jobTitle) body.job_title = jobTitle;
+  if (sendInvite === false) body.send_invite = false;
+  return client.request('/contractors', json('POST', body));
+}
+
+/** Issue a new portal link (the old one stops working). Returns the URL. */
+export async function createContractorPortalLink(client, contractorId, { sendEmail } = {}) {
+  const data = await client.request(`/contractors/${id(contractorId)}/portal-link`, json('POST', { send_email: !!sendEmail }));
+  return data.url;
+}
+
+/** Offboard: ends live contracts and revokes the portal link. Records are kept. */
+export async function offboardContractor(client, contractorId) {
+  return client.request('/contractors/' + id(contractorId), { method: 'DELETE' });
+}
+
+/**
+ * Draft a contract. kind: 'fixed' (rate per frequency), 'hourly' (rate per
+ * hour) or 'milestone' (milestones: [{ title, amount, due_date? }]).
+ */
+export async function createContract(client, contractorId, { title, scope, kind, rate, frequency, startDate, endDate, firstPayDate, milestones }) {
+  const body = { title, kind };
+  if (scope) body.scope = scope;
+  if (rate !== undefined) body.rate = rate;
+  if (frequency) body.frequency = frequency;
+  if (startDate) body.start_date = startDate;
+  if (endDate) body.end_date = endDate;
+  if (firstPayDate) body.first_pay_date = firstPayDate;
+  if (milestones) body.milestones = milestones;
+  const data = await client.request(`/contractors/${id(contractorId)}/contracts`, json('POST', body));
+  return data.contract;
+}
+
+/** Sign a draft contract as the business and send it to the contractor. */
+export async function sendContract(client, contractId, { signature }) {
+  const data = await client.request('/contractor-contracts/' + id(contractId), json('PATCH', { action: 'send', signature }));
+  return data.contract;
+}
+
+export async function endContract(client, contractId, { reason, endDate } = {}) {
+  const data = await client.request('/contractor-contracts/' + id(contractId), json('PATCH', { action: 'end', reason, end_date: endDate }));
+  return data.contract;
+}
+
+/** Work lines: hours, milestones, expenses, bonuses and fixed fees. status: submitted|approved|rejected|paid */
+export async function listWorkItems(client, { businessId, status, contractorId } = {}) {
+  const data = await client.request('/contractor-work-items' + q({ business_id: businessId, status, contractor_id: contractorId }));
+  return data.work_items ?? [];
+}
+
+/** Approve or reject a submission. A rejection needs a note. */
+export async function reviewWorkItem(client, workItemId, { action, note }) {
+  const data = await client.request('/contractor-work-items/' + id(workItemId), json('PATCH', { action, note }));
+  return data.work_item;
+}
+
+/** Add a bonus or an expense reimbursement (approved immediately). */
+export async function addContractorPayment(client, { businessId, contractId, kind, amount, description }) {
+  const body = { contract_id: contractId, kind, amount, description };
+  if (businessId) body.business_id = businessId;
+  const data = await client.request('/contractor-work-items', json('POST', body));
+  return data.work_item;
+}
+
+export async function listPayRuns(client, { businessId } = {}) {
+  const data = await client.request('/pay-runs' + q({ business_id: businessId }));
+  return data.pay_runs ?? [];
+}
+
+/** A run with one item per contractor, its lines, and any warnings. */
+export async function getPayRun(client, payRunId) {
+  return client.request('/pay-runs/' + id(payRunId));
+}
+
+/** Draft a pay run (fixed fees due by payDate plus approved work). Moves no money. */
+export async function createPayRun(client, { businessId, payDate } = {}) {
+  const body = {};
+  if (businessId) body.business_id = businessId;
+  if (payDate) body.pay_date = payDate;
+  const data = await client.request('/pay-runs', json('POST', body));
+  return data.pay_run;
+}
+
+export async function deletePayRun(client, payRunId) {
+  return client.request('/pay-runs/' + id(payRunId), { method: 'DELETE' });
+}
+
+/** Send a run (or some items) from the business payout wallet. Owner session only. */
+export async function payPayRun(client, payRunId, { itemIds } = {}) {
+  return client.request(`/pay-runs/${id(payRunId)}/pay`, json('POST', itemIds ? { method: 'wallet', item_ids: itemIds } : { method: 'wallet' }));
+}
+
+/** Record payments made from your own wallet: [{ itemId, txHash }]. Owner session only. */
+export async function recordPayRunPayments(client, payRunId, payments) {
+  return client.request(
+    `/pay-runs/${id(payRunId)}/pay`,
+    json('POST', { method: 'manual', payments: payments.map((p) => ({ item_id: p.itemId, tx_hash: p.txHash })) })
+  );
+}
+
+/** Per-contractor totals for a calendar year and who needs a 1099-NEC. */
+export async function get1099Summary(client, { businessId, year } = {}) {
+  return client.request('/contractors/1099' + q({ business_id: businessId, year }));
+}

package/src/index.d.ts

@@ -76,6 +76,45 @@ export type {
   ListInvoicesResult,
 } from './invoices.js';
 
+// Projects, time, aging, invoice settings, portal links
+export {
+  getArAging,
+  getInvoiceSettings,
+  updateInvoiceSettings,
+  createClientPortalLink,
+  revokeClientPortalLink,
+  listProjects,
+  getProject,
+  createProject,
+  logTime,
+  startTimer,
+  stopTimer,
+  listTimeEntries,
+  invoiceProjectTime,
+} from './projects.js';
+export type { ArAging, AgingRow, InvoiceSettings, Project, ProjectStats, TimeEntry } from './projects.js';
+export {
+  listContractors,
+  getContractor,
+  addContractor,
+  createContractorPortalLink,
+  offboardContractor,
+  createContract,
+  sendContract,
+  endContract,
+  listWorkItems,
+  reviewWorkItem,
+  addContractorPayment,
+  listPayRuns,
+  getPayRun,
+  createPayRun,
+  deletePayRun,
+  payPayRun,
+  recordPayRunPayments,
+  get1099Summary,
+} from './contractors.js';
+export type { Contractor, ContractorContract, ContractorMilestone, ContractorWorkItem, PayRun, PayRunItem, PayOutcome } from './contractors.js';
+
 // Webhook exports
 export {
   verifyWebhookSignature,

package/src/index.js

@@ -90,6 +90,44 @@ import {
   deleteInvoiceItem,
 } from './invoices.js';
 
+// Projects, time, aging, invoice settings, portal links
+import {
+  getArAging,
+  getInvoiceSettings,
+  updateInvoiceSettings,
+  createClientPortalLink,
+  revokeClientPortalLink,
+  listProjects,
+  getProject,
+  createProject,
+  logTime,
+  startTimer,
+  stopTimer,
+  listTimeEntries,
+  invoiceProjectTime,
+} from './projects.js';
+
+import {
+  listContractors,
+  getContractor,
+  addContractor,
+  createContractorPortalLink,
+  offboardContractor,
+  createContract,
+  sendContract,
+  endContract,
+  listWorkItems,
+  reviewWorkItem,
+  addContractorPayment,
+  listPayRuns,
+  getPayRun,
+  createPayRun,
+  deletePayRun,
+  payPayRun,
+  recordPayRunPayments,
+  get1099Summary,
+} from './contractors.js';
+
 // Wallet exports
 import {
   WalletClient,
@@ -243,6 +281,37 @@ export {
   listInvoiceItems,
   createInvoiceItem,
   deleteInvoiceItem,
+  getArAging,
+  getInvoiceSettings,
+  updateInvoiceSettings,
+  createClientPortalLink,
+  revokeClientPortalLink,
+  listProjects,
+  getProject,
+  createProject,
+  logTime,
+  startTimer,
+  stopTimer,
+  listTimeEntries,
+  invoiceProjectTime,
+  listContractors,
+  getContractor,
+  addContractor,
+  createContractorPortalLink,
+  offboardContractor,
+  createContract,
+  sendContract,
+  endContract,
+  listWorkItems,
+  reviewWorkItem,
+  addContractorPayment,
+  listPayRuns,
+  getPayRun,
+  createPayRun,
+  deletePayRun,
+  payPayRun,
+  recordPayRunPayments,
+  get1099Summary,
   
   // Wallet
   WalletClient,

package/src/mcp.js

@@ -15,6 +15,9 @@ import { createInterface } from 'node:readline';
 import * as reports from './finances-reports.js';
 import { getFinanceSummary, listFinanceAccounts, listFinanceTransactions } from './finances.js';
 import * as sf from './statements-fetch.js';
+import { listInvoices, getInvoice, createInvoice } from './invoices.js';
+import * as projects from './projects.js';
+import * as contractors from './contractors.js';
 
 export const PROTOCOL_VERSION = '2025-06-18';
 
@@ -218,6 +221,169 @@ export const TOOLS = [
       return { ...text({ banks: results }), isError: false };
     },
   },
+  {
+    name: 'invoice_list',
+    description: 'List invoices (number, status, amount, currency, due date, client). Filter by status: draft, sent, overdue, paid, cancelled.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        businessId: { type: 'string' },
+        status: { type: 'string', enum: ['draft', 'sent', 'overdue', 'paid', 'cancelled'] },
+        clientId: { type: 'string' },
+      },
+      additionalProperties: false,
+    },
+    handler: async (args, { client }) => text(await listInvoices(client, args)),
+  },
+  {
+    name: 'invoice_get',
+    description: 'One invoice with its line items, totals, payment details and status.',
+    inputSchema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'], additionalProperties: false },
+    handler: async (args, { client }) => text(await getInvoice(client, args.id)),
+  },
+  {
+    name: 'invoice_create_draft',
+    description:
+      'Create a DRAFT itemised invoice (nothing is sent). lineItems: [{description, quantity, unit_price, tax_rate?, tax_name?}]; discount: {type: percent|fixed, value}. The server computes the total.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        businessId: { type: 'string' },
+        clientId: { type: 'string' },
+        currency: { type: 'string', description: 'ISO code, default USD' },
+        dueDate: { type: 'string', description: 'ISO date' },
+        notes: { type: 'string' },
+        lineItems: {
+          type: 'array',
+          minItems: 1,
+          maxItems: 100,
+          items: {
+            type: 'object',
+            properties: {
+              description: { type: 'string' },
+              quantity: { type: 'number' },
+              unit_price: { type: 'number' },
+              tax_rate: { type: 'number' },
+              tax_name: { type: 'string' },
+            },
+            required: ['description', 'quantity', 'unit_price'],
+            additionalProperties: false,
+          },
+        },
+        discount: {
+          type: 'object',
+          properties: { type: { type: 'string', enum: ['percent', 'fixed'] }, value: { type: 'number' } },
+          required: ['type', 'value'],
+          additionalProperties: false,
+        },
+      },
+      required: ['lineItems'],
+      additionalProperties: false,
+    },
+    handler: async (args, { client }) => text(await createInvoice(client, { ...args, currency: args.currency || 'USD' })),
+  },
+  {
+    name: 'invoice_ar_aging',
+    description: 'Accounts receivable aging: unpaid sent invoices by days past due (current, 1-30, 31-60, 61-90, 90+), per currency and per client.',
+    inputSchema: { type: 'object', properties: { businessId: { type: 'string' } }, additionalProperties: false },
+    handler: async (args, { client }) => text(await projects.getArAging(client, args)),
+  },
+  {
+    name: 'project_list',
+    description: 'List active projects (name, client, hourly rate, budget).',
+    inputSchema: { type: 'object', properties: { businessId: { type: 'string' }, includeArchived: { type: 'boolean' } }, additionalProperties: false },
+    handler: async (args, { client }) => text({ projects: await projects.listProjects(client, args) }),
+  },
+  {
+    name: 'project_get',
+    description: 'One project with hours logged, unbilled value, billed and paid totals.',
+    inputSchema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'], additionalProperties: false },
+    handler: async (args, { client }) => text(await projects.getProject(client, args.id)),
+  },
+  {
+    name: 'time_log',
+    description: 'Log finished time on a project, in minutes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectId: { type: 'string' },
+        minutes: { type: 'integer', minimum: 1, maximum: 100000 },
+        description: { type: 'string' },
+        billable: { type: 'boolean' },
+      },
+      required: ['projectId', 'minutes'],
+      additionalProperties: false,
+    },
+    handler: async (args, { client }) => text({ time_entry: await projects.logTime(client, args) }),
+  },
+  {
+    name: 'project_invoice_time',
+    description: "Bill a project's unbilled billable time as a DRAFT itemised invoice (not sent). Returns the invoice number and amount.",
+    inputSchema: { type: 'object', properties: { projectId: { type: 'string' } }, required: ['projectId'], additionalProperties: false },
+    handler: async (args, { client }) => text(await projects.invoiceProjectTime(client, args.projectId)),
+  },
+  // Contractors. None of these sends money: paying a run is a signed-in owner's act in the dashboard or CLI.
+  {
+    name: 'contractor_list',
+    description: 'List contractors with wallet and tax-form status and how many submissions wait for approval.',
+    inputSchema: { type: 'object', properties: { businessId: { type: 'string' }, includeOffboarded: { type: 'boolean' } }, additionalProperties: false },
+    handler: async (args, { client }) => text({ contractors: await contractors.listContractors(client, args) }),
+  },
+  {
+    name: 'contractor_get',
+    description: 'One contractor: contracts and milestones, work lines and payments.',
+    inputSchema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'], additionalProperties: false },
+    handler: async (args, { client }) => text(await contractors.getContractor(client, args.id)),
+  },
+  {
+    name: 'contractor_work_list',
+    description: 'Contractor work lines (hours, milestones, expenses, bonuses, fixed fees). Use status "submitted" for what waits for approval.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        businessId: { type: 'string' },
+        status: { type: 'string', enum: ['submitted', 'approved', 'rejected', 'paid'] },
+        contractorId: { type: 'string' },
+      },
+      additionalProperties: false,
+    },
+    handler: async (args, { client }) => text({ work_items: await contractors.listWorkItems(client, args) }),
+  },
+  {
+    name: 'contractor_work_review',
+    description: 'Approve or reject a submitted work line. A rejection needs a note the contractor will see. Approving does not pay; it queues the line for the next pay run.',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string' }, action: { type: 'string', enum: ['approve', 'reject'] }, note: { type: 'string' } },
+      required: ['id', 'action'],
+      additionalProperties: false,
+    },
+    handler: async (args, { client }) => text({ work_item: await contractors.reviewWorkItem(client, args.id, args) }),
+  },
+  {
+    name: 'pay_run_list',
+    description: 'Pay runs with totals and how many contractors are paid.',
+    inputSchema: { type: 'object', properties: { businessId: { type: 'string' } }, additionalProperties: false },
+    handler: async (args, { client }) => text({ pay_runs: await contractors.listPayRuns(client, args) }),
+  },
+  {
+    name: 'pay_run_get',
+    description: 'One pay run: per-contractor amounts, lines, status and warnings (missing or recently changed wallets).',
+    inputSchema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'], additionalProperties: false },
+    handler: async (args, { client }) => text(await contractors.getPayRun(client, args.id)),
+  },
+  {
+    name: 'pay_run_draft',
+    description: 'Draft a pay run from fixed fees due by payDate (YYYY-MM-DD, default today) plus all approved work. Sends nothing; the owner reviews and pays it.',
+    inputSchema: { type: 'object', properties: { businessId: { type: 'string' }, payDate: { type: 'string' } }, additionalProperties: false },
+    handler: async (args, { client }) => text({ pay_run: await contractors.createPayRun(client, args) }),
+  },
+  {
+    name: 'contractor_1099_summary',
+    description: 'Totals paid per contractor in a calendar year and who needs a 1099-NEC (US, $600+, not a corporation). Shows only the last four of tax ids.',
+    inputSchema: { type: 'object', properties: { businessId: { type: 'string' }, year: { type: 'integer' } }, additionalProperties: false },
+    handler: async (args, { client }) => text(await contractors.get1099Summary(client, args)),
+  },
 ];
 
 /** Answer one JSON-RPC message; null for a notification. */

package/src/projects.d.ts

@@ -0,0 +1,91 @@
+import type { CoinPayClient } from './client.js';
+
+export interface AgingRow {
+  currency: string;
+  current: number;
+  '1_30': number;
+  '31_60': number;
+  '61_90': number;
+  '90_plus': number;
+  total: number;
+}
+
+export interface ArAging {
+  as_of: string;
+  totals: AgingRow[];
+  clients: Array<AgingRow & { client_id: string | null; name: string; invoices: number }>;
+}
+
+export interface InvoiceSettings {
+  business_id: string;
+  reminders_enabled: boolean;
+  reminder_days: number[];
+  late_fee_type: 'none' | 'percent' | 'fixed';
+  late_fee_value: number | null;
+  late_fee_after_days: number;
+  brand_color: string | null;
+  logo_url: string | null;
+  invoice_footer: string | null;
+}
+
+export interface Project {
+  id: string;
+  business_id: string;
+  client_id: string | null;
+  name: string;
+  hourly_rate: number | null;
+  currency: string;
+  budget_hours: number | null;
+  status: 'active' | 'archived';
+}
+
+export interface ProjectStats {
+  hours: number;
+  billable_hours: number;
+  unbilled_amount: number;
+  billed_amount: number;
+  paid_amount: number;
+}
+
+export interface TimeEntry {
+  id: string;
+  project_id: string;
+  description: string;
+  started_at: string;
+  ended_at: string | null;
+  /** null while the timer is running */
+  minutes: number | null;
+  billable: boolean;
+  hourly_rate: number | null;
+  invoice_id: string | null;
+}
+
+export function getArAging(client: CoinPayClient, options?: { businessId?: string }): Promise<ArAging>;
+export function getInvoiceSettings(client: CoinPayClient, options?: { businessId?: string }): Promise<InvoiceSettings>;
+export function updateInvoiceSettings(
+  client: CoinPayClient,
+  options: { businessId?: string } & Partial<Omit<InvoiceSettings, 'business_id'>>
+): Promise<InvoiceSettings>;
+export function createClientPortalLink(client: CoinPayClient, clientId: string): Promise<string>;
+export function revokeClientPortalLink(client: CoinPayClient, clientId: string): Promise<Record<string, unknown>>;
+export function listProjects(client: CoinPayClient, options?: { businessId?: string; includeArchived?: boolean }): Promise<Project[]>;
+export function getProject(client: CoinPayClient, id: string): Promise<{ project: Project; stats: ProjectStats }>;
+export function createProject(
+  client: CoinPayClient,
+  options: { businessId?: string; name: string; clientId?: string; hourlyRate?: number; currency?: string; budgetHours?: number; notes?: string }
+): Promise<Project>;
+export function logTime(
+  client: CoinPayClient,
+  options: { projectId: string; minutes: number; description?: string; billable?: boolean; hourlyRate?: number; startedAt?: string }
+): Promise<TimeEntry>;
+export function startTimer(client: CoinPayClient, options: { projectId: string; description?: string }): Promise<TimeEntry>;
+export function stopTimer(client: CoinPayClient, options?: { entryId?: string; businessId?: string }): Promise<TimeEntry>;
+export function listTimeEntries(
+  client: CoinPayClient,
+  options?: { projectId?: string; businessId?: string; unbilled?: boolean }
+): Promise<TimeEntry[]>;
+export function invoiceProjectTime(
+  client: CoinPayClient,
+  projectId: string,
+  options?: { entryIds?: string[] }
+): Promise<{ invoice: { id: string; invoice_number: string; amount: number }; entries_billed: number }>;