@aduek/ne-sy 0.1.0-alpha.0

package/README.md

@@ -0,0 +1,92 @@
+# Aduek TypeScript SDK
+
+TypeScript package foundation for Aduek Ne-Sy.
+
+The TypeScript SDK should feel native for SaaS apps, web agents, browser automation, internal tools, workflow apps, Next.js backends, and production agent applications.
+
+## Target Ergonomics
+
+```ts
+import { verifyAction } from "@aduek/ne-sy";
+
+const decision = await verifyAction({ agent, action, context });
+if (decision.allowed) await tool.execute(action);
+```
+
+## Planned Responsibilities
+
+- Action model bindings
+- Local verifier API
+- Tool wrapper helpers
+- JSONL audit event emitter
+- Framework adapters
+
+## Current Sprint State
+
+The SDK now includes a local evaluator for explicit policy packs, dotted-path condition checks, decision precedence, JSON Schema-backed policy-pack validation, policy analysis, async tool wrapping, and JSONL audit writing.
+
+Policy packs can declare a default decision for no-match actions, and audit events include policy-pack metadata for reviewer traceability.
+
+The implementation is split into focused modules for types, policy evaluation, audit events, runtime schema validation, verifier entrypoints, and shared utilities while preserving the public `@aduek/ne-sy` export surface.
+
+Policy packs can also be normalized into a deterministic policy IR for static analysis and future solver adapters:
+
+```ts
+import { hashPolicyIr, normalizePolicyPack } from "@aduek/ne-sy";
+
+const policyIr = normalizePolicyPack(policyPack);
+hashPolicyIr(policyIr);
+```
+
+Finite-domain bounded simulation can run over the normalized IR without adding solver dependencies:
+
+```ts
+simulatePolicyIr(policyIr, simulationSpec);
+```
+
+Policy evidence can be reproduced with:
+
+```ts
+import { hashPolicyPack } from "@aduek/ne-sy";
+
+hashPolicyPack(policyPack)
+```
+
+Generic tool adapters can create the shared action shape with:
+
+```ts
+createToolAction({ agent, tool, args })
+```
+
+OpenAI Agents SDK custom function-tool input guardrails can use a dependency-light boundary:
+
+```ts
+const result = await runOpenAiToolInputGuardrail({
+  agent,
+  toolName: "loan_approve",
+  toolArguments: { amount: 150000 },
+  policies: policyPack,
+  context,
+});
+```
+
+The result maps `allow` and `log` to guardrail allow, and `deny` and `review` to `rejectContent`. The base package does not depend on the OpenAI Agents SDK.
+
+HubSpot-shaped outcome fixtures can be classified locally for planned paid-pilot evidence:
+
+```ts
+import { classifyHubSpotOutcomes, exportHubSpotCreditsRows, loadHubSpotOutcomeEvents } from "@aduek/ne-sy";
+
+const events = loadHubSpotOutcomeEvents("examples/hubspot-outcomes/hubspot-outcome-events.json");
+const ledger = classifyHubSpotOutcomes(events);
+const creditsRows = exportHubSpotCreditsRows(ledger.records);
+```
+
+This is local fixture/evidence tooling only. It does not add OAuth, webhook verification, HubSpot API writes, HubSpot Credits writes, hosted billing, or payment collection.
+
+Package metadata is now set for alpha prerelease dry-run work at version `0.1.0-alpha.0`.
+
+## Current Technical Debt
+
+- Framework-specific adapters beyond the OpenAI Agents tool input guardrail boundary are not implemented yet.
+- Required package content assertions, initial changelog, alpha release notes, and manual artifact inspection are implemented; publishing approval remains out of scope.

package/dist/adapters.d.ts

@@ -0,0 +1,13 @@
+export interface ToolActionInput<Args extends unknown[] = unknown[]> {
+    agent: unknown;
+    tool?: (...args: Args) => unknown;
+    toolName?: string;
+    args?: Args;
+    actionType?: string;
+    target?: unknown;
+    metadata?: Record<string, unknown>;
+    actionId?: string;
+    timestamp?: string;
+}
+export declare function createToolAction<Args extends unknown[] = unknown[]>(input: ToolActionInput<Args>): Record<string, unknown>;
+//# sourceMappingURL=adapters.d.ts.map

package/dist/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../src/adapters.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,eAAe,CAAC,IAAI,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE;IACjE,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,gBAAgB,CAAC,IAAI,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,EACjE,KAAK,EAAE,eAAe,CAAC,IAAI,CAAC,GAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiBzB"}

package/dist/adapters.js

@@ -0,0 +1,20 @@
+import { randomUUID } from "node:crypto";
+import { agentRef } from "./utils.js";
+export function createToolAction(input) {
+    const toolName = input.toolName ?? input.tool?.name ?? "tool";
+    return {
+        id: input.actionId ?? randomUUID(),
+        type: input.actionType ?? "tool.call",
+        actor: agentRef(input.agent),
+        target: input.target ?? {
+            id: toolName,
+            kind: "function",
+            trustBoundary: "internal",
+        },
+        input: {
+            args: [...(input.args ?? [])],
+        },
+        metadata: input.metadata ?? {},
+        timestamp: input.timestamp ?? new Date().toISOString(),
+    };
+}

package/dist/audit.d.ts

@@ -0,0 +1,14 @@
+import type { AuditEvent, Decision } from "./types.js";
+export declare function createAuditEvent(input: {
+    agent: unknown;
+    action: unknown;
+    context: unknown;
+    decision: Decision;
+    policyPackId?: string;
+    policyVersion?: string;
+    policyHash?: string;
+}): AuditEvent;
+export declare function writeAuditEvent(path: string, event: AuditEvent): Promise<void>;
+export declare function validateAuditEvent(event: unknown): string[];
+export declare function assertValidAuditEvent(event: unknown): asserts event is AuditEvent;
+//# sourceMappingURL=audit.d.ts.map

package/dist/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../src/audit.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAoB,MAAM,YAAY,CAAC;AAUzE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,UAAU,CA+Cb;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAWpF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CA6C3D;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,UAAU,CAQjF"}

package/dist/audit.js

@@ -0,0 +1,129 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, appendFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { DECISION_RANK, PolicyEvaluationError } from "./types.js";
+import { VERIFIER_VERSION, hashAction, hashAuditEvidence, hashEnvelope, } from "./evidence.js";
+import { isRecord } from "./utils.js";
+import { validateAuditEventSchema } from "./validation.js";
+export function createAuditEvent(input) {
+    let executionOutcome;
+    if (input.decision.decision === "review") {
+        executionOutcome = "pending_review";
+    }
+    else if (input.decision.decision === "deny") {
+        executionOutcome = "blocked";
+    }
+    else {
+        executionOutcome = "executed";
+    }
+    const event = {
+        id: randomUUID(),
+        action: input.action,
+        decision: {
+            decision: input.decision.decision,
+            reason: input.decision.reason,
+            matchedPolicyIds: input.decision.matchedPolicyIds,
+            metadata: input.decision.metadata,
+        },
+        runtime: {
+            agent: input.agent,
+            context: input.context,
+            executionOutcome,
+        },
+        timestamp: new Date().toISOString(),
+    };
+    if (input.policyPackId) {
+        event.policyPackId = input.policyPackId;
+    }
+    if (input.policyVersion) {
+        event.policyVersion = input.policyVersion;
+    }
+    if (input.policyHash) {
+        event.policyHash = input.policyHash;
+    }
+    event.actionHash = hashAction(input.action);
+    event.envelopeHash = hashEnvelope({
+        agent: input.agent,
+        action: input.action,
+        context: input.context,
+        policyPackId: input.policyPackId,
+        policyVersion: input.policyVersion,
+        policyHash: input.policyHash,
+    });
+    event.verifierVersion = VERIFIER_VERSION;
+    event.evidenceHash = hashAuditEvidence(event);
+    return event;
+}
+export async function writeAuditEvent(path, event) {
+    try {
+        await mkdir(dirname(path), { recursive: true });
+        await appendFile(path, `${JSON.stringify(event)}\n`, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new PolicyEvaluationError(`Audit write failed: ${message}`, {
+            category: "audit_write_error",
+            code: "audit_write_failed",
+        });
+    }
+}
+export function validateAuditEvent(event) {
+    const errors = validateAuditEventSchema(event);
+    if (!isRecord(event))
+        return ["event must be an object"];
+    requireString(event, "id", errors);
+    requireObject(event, "action", errors);
+    requireObject(event, "decision", errors);
+    requireString(event, "timestamp", errors);
+    if (isRecord(event.decision)) {
+        if (!Object.prototype.hasOwnProperty.call(DECISION_RANK, String(event.decision.decision))) {
+            errors.push("decision.decision must be one of allow, deny, review, log");
+        }
+        requireString(event.decision, "reason", errors, "decision.");
+        if (event.decision.matchedPolicyIds !== undefined &&
+            (!Array.isArray(event.decision.matchedPolicyIds) ||
+                !event.decision.matchedPolicyIds.every((item) => typeof item === "string"))) {
+            errors.push("decision.matchedPolicyIds must be a list of strings");
+        }
+    }
+    if (event.policyVersion !== undefined && typeof event.policyVersion !== "string") {
+        errors.push("policyVersion must be a string when present");
+    }
+    if (event.policyPackId !== undefined && typeof event.policyPackId !== "string") {
+        errors.push("policyPackId must be a string when present");
+    }
+    if (event.policyHash !== undefined && typeof event.policyHash !== "string") {
+        errors.push("policyHash must be a string when present");
+    }
+    for (const hashField of ["actionHash", "envelopeHash", "evidenceHash"]) {
+        if (event[hashField] !== undefined && typeof event[hashField] !== "string") {
+            errors.push(`${hashField} must be a string when present`);
+        }
+    }
+    if (event.verifierVersion !== undefined && typeof event.verifierVersion !== "string") {
+        errors.push("verifierVersion must be a string when present");
+    }
+    if (event.runtime !== undefined && !isRecord(event.runtime)) {
+        errors.push("runtime must be an object when present");
+    }
+    return errors;
+}
+export function assertValidAuditEvent(event) {
+    const errors = validateAuditEvent(event);
+    if (errors.length > 0) {
+        throw new PolicyEvaluationError(errors.join("; "), {
+            category: "validation_error",
+            code: "audit_event_validation_error",
+        });
+    }
+}
+function requireString(record, key, errors, prefix = "") {
+    if (typeof record[key] !== "string") {
+        errors.push(`${prefix}${key} must be a string`);
+    }
+}
+function requireObject(record, key, errors, prefix = "") {
+    if (!isRecord(record[key])) {
+        errors.push(`${prefix}${key} must be an object`);
+    }
+}

package/dist/capabilities.d.ts

@@ -0,0 +1,10 @@
+export declare const CAPABILITY_VOCABULARY: Set<string>;
+export declare const BOUNDED_SIMULATION_CAPABILITIES: Set<string>;
+export interface CapabilityValidation {
+    ok: boolean;
+    reason?: string;
+    errorCode?: string;
+}
+export declare function validateRequiredCapabilities(capabilities: unknown, supported: Set<string>): CapabilityValidation;
+export declare function validateCapabilityList(capabilities: unknown): CapabilityValidation;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,aAgBhC,CAAC;AAEH,eAAO,MAAM,+BAA+B,aAS1C,CAAC;AAEH,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,OAAO,EACrB,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GACrB,oBAAoB,CA6CtB;AAED,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,OAAO,GAAG,oBAAoB,CAUlF"}

package/dist/capabilities.js

@@ -0,0 +1,89 @@
+export const CAPABILITY_VOCABULARY = new Set([
+    "policy.conditions.basic",
+    "policy.operators.equals",
+    "policy.operators.not_equals",
+    "policy.operators.greater_than",
+    "policy.operators.less_than",
+    "policy.operators.in",
+    "analysis.bounded_simulation",
+    "analysis.typed_field_registry",
+    "analysis.solver.numeric",
+    "analysis.solver.enum",
+    "analysis.explanation.facts",
+    "evidence.policy_hash",
+    "evidence.policy_ir_hash",
+    "evidence.hashes",
+    "evidence.replay_manifest",
+]);
+export const BOUNDED_SIMULATION_CAPABILITIES = new Set([
+    "policy.conditions.basic",
+    "policy.operators.equals",
+    "policy.operators.not_equals",
+    "policy.operators.greater_than",
+    "policy.operators.less_than",
+    "policy.operators.in",
+    "analysis.bounded_simulation",
+    "analysis.typed_field_registry",
+]);
+export function validateRequiredCapabilities(capabilities, supported) {
+    if (capabilities === undefined || capabilities === null)
+        return { ok: true };
+    if (!isRecord(capabilities)) {
+        return {
+            ok: false,
+            reason: "Capability declarations must be an object.",
+            errorCode: "simulation_invalid_capabilities",
+        };
+    }
+    const requires = capabilities.requires ?? [];
+    if (!Array.isArray(requires) || !requires.every((item) => typeof item === "string")) {
+        return {
+            ok: false,
+            reason: "Capability `requires` must be an array of strings.",
+            errorCode: "simulation_invalid_capabilities",
+        };
+    }
+    const supportedBy = capabilities.supportedBy ?? {};
+    if (supportedBy !== undefined && supportedBy !== null) {
+        if (!isRecord(supportedBy)) {
+            return {
+                ok: false,
+                reason: "Capability `supportedBy` must be an object.",
+                errorCode: "simulation_invalid_capabilities",
+            };
+        }
+        for (const [consumer, values] of Object.entries(supportedBy)) {
+            if (typeof consumer !== "string" || !Array.isArray(values) || !values.every((item) => typeof item === "string")) {
+                return {
+                    ok: false,
+                    reason: "Capability `supportedBy` entries must be arrays of strings.",
+                    errorCode: "simulation_invalid_capabilities",
+                };
+            }
+        }
+    }
+    const unsupported = requires.filter((item) => !supported.has(item));
+    if (unsupported.length > 0) {
+        return {
+            ok: false,
+            reason: `Unsupported required capabilities: ${JSON.stringify(unsupported)}`,
+            errorCode: "simulation_unsupported_capability",
+        };
+    }
+    return { ok: true };
+}
+export function validateCapabilityList(capabilities) {
+    if (capabilities === undefined || capabilities === null)
+        return { ok: true };
+    if (!Array.isArray(capabilities) || !capabilities.every((item) => typeof item === "string")) {
+        return {
+            ok: false,
+            reason: "Capability list must be an array of strings.",
+            errorCode: "simulation_invalid_capabilities",
+        };
+    }
+    return { ok: true };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/evidence.d.ts

@@ -0,0 +1,19 @@
+export declare const EVIDENCE_HASH_ALGORITHM = "sha256";
+export declare const VERIFIER_VERSION = "0.1.0-alpha.0";
+export declare function canonicalEvidenceJson(value: unknown, options?: {
+    excludeSelfHashes?: boolean;
+}): string;
+export declare function hashEvidenceValue(value: unknown, options?: {
+    excludeSelfHashes?: boolean;
+}): string;
+export declare function hashAction(action: unknown): string;
+export declare function hashEnvelope(input: {
+    agent: unknown;
+    action: unknown;
+    context: unknown;
+    policyPackId?: string;
+    policyVersion?: string;
+    policyHash?: string;
+}): string;
+export declare function hashAuditEvidence(event: Record<string, unknown>): string;
+//# sourceMappingURL=evidence.d.ts.map

package/dist/evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../src/evidence.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB,WAAW,CAAC;AAChD,eAAO,MAAM,gBAAgB,kBAAkB,CAAC;AAIhD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE;IAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC5C,MAAM,CAER;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,OAAO,GAAE;IAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC5C,MAAM,CAIR;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,MAAM,CAST;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAExE"}

package/dist/evidence.js

@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+import { compareStrings, isRecord } from "./utils.js";
+export const EVIDENCE_HASH_ALGORITHM = "sha256";
+export const VERIFIER_VERSION = "0.1.0-alpha.0";
+const SELF_REFERENTIAL_HASH_FIELDS = new Set(["evidenceHash"]);
+export function canonicalEvidenceJson(value, options = {}) {
+    return JSON.stringify(canonicalEvidenceValue(value, options));
+}
+export function hashEvidenceValue(value, options = {}) {
+    return createHash(EVIDENCE_HASH_ALGORITHM)
+        .update(canonicalEvidenceJson(value, options), "utf8")
+        .digest("hex");
+}
+export function hashAction(action) {
+    return hashEvidenceValue(action);
+}
+export function hashEnvelope(input) {
+    return hashEvidenceValue({
+        agent: input.agent,
+        action: input.action,
+        context: input.context,
+        policyPackId: input.policyPackId ?? null,
+        policyVersion: input.policyVersion ?? null,
+        policyHash: input.policyHash ?? null,
+    });
+}
+export function hashAuditEvidence(event) {
+    return hashEvidenceValue(event, { excludeSelfHashes: true });
+}
+function canonicalEvidenceValue(value, options) {
+    if (Array.isArray(value)) {
+        return value.map((item) => canonicalEvidenceValue(item, options));
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([key, entry]) => entry !== undefined &&
+            !(options.excludeSelfHashes && SELF_REFERENTIAL_HASH_FIELDS.has(key)))
+            .sort(([left], [right]) => compareStrings(left, right))
+            .map(([key, entry]) => [key, canonicalEvidenceValue(entry, options)]));
+    }
+    if (typeof value === "number" && !Number.isFinite(value)) {
+        throw new Error("Evidence hash payloads must not contain NaN or Infinity.");
+    }
+    if (value === undefined || typeof value === "function" || typeof value === "symbol") {
+        throw new Error("Evidence hash payloads must contain JSON-compatible values only.");
+    }
+    return value;
+}

package/dist/hubspot.d.ts

@@ -0,0 +1,59 @@
+export type HubSpotOutcomeType = "resolved_conversation" | "qualified_lead_recommended" | "workflow_completed";
+export type HubSpotLifecycleState = "candidate" | "verified" | "rejected" | "reversed" | "exported";
+export type HubSpotRejectionReason = "malformed_event" | "unsupported_outcome_type" | "duplicate_idempotency_key" | "missing_required_evidence" | "human_escalation" | "reopened_conversation" | "unknown_reversal_target";
+export interface HubSpotOutcomeRecord {
+    eventId: string | null;
+    portalId: string | null;
+    appId: string | null;
+    agentId: string | null;
+    outcomeType: string | null;
+    idempotencyKey: string | null;
+    lifecycleState: HubSpotLifecycleState;
+    billable: boolean;
+    exportEligible: boolean;
+    adjustmentQuantity: number;
+    rejectionReason: HubSpotRejectionReason | null;
+    reversalOf: string | null;
+    occurredAt: string | null;
+}
+export interface HubSpotOutcomeSummary {
+    totalRecords: number;
+    billableRecords: number;
+    exportEligibleRecords: number;
+    byLifecycleState: Record<string, number>;
+    byOutcomeType: Record<string, number>;
+    byRejectionReason: Record<string, number>;
+}
+export interface HubSpotOutcomeLedger {
+    records: HubSpotOutcomeRecord[];
+    summary: HubSpotOutcomeSummary;
+}
+export interface HubSpotCreditsRow {
+    portalId: string | null;
+    appId: string | null;
+    outcomeType: string | null;
+    idempotencyKey: string | null;
+    lifecycleState: HubSpotLifecycleState;
+    quantity: number;
+    sourceEventId: string | null;
+    reversalOf: string | null;
+    occurredAt: string | null;
+}
+export interface HubSpotInvoiceLineRow {
+    portalId: string | null;
+    appId: string | null;
+    agentId: string | null;
+    outcomeType: string | null;
+    idempotencyKey: string | null;
+    quantity: number;
+    description: string;
+    sourceEventId: string | null;
+    reversalOf: string | null;
+    occurredAt: string | null;
+}
+export declare function loadHubSpotOutcomeEvents(path: string): unknown[];
+export declare function classifyHubSpotOutcomes(events: Iterable<unknown>): HubSpotOutcomeLedger;
+export declare function summarizeHubSpotOutcomes(records: Iterable<HubSpotOutcomeRecord>): HubSpotOutcomeSummary;
+export declare function exportHubSpotCreditsRows(records: Iterable<HubSpotOutcomeRecord>): HubSpotCreditsRow[];
+export declare function exportHubSpotInvoiceLineRows(records: Iterable<HubSpotOutcomeRecord>): HubSpotInvoiceLineRow[];
+//# sourceMappingURL=hubspot.d.ts.map

package/dist/hubspot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hubspot.d.ts","sourceRoot":"","sources":["../src/hubspot.ts"],"names":[],"mappings":"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"}