@terminator-network/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,356 @@
+import { z } from 'zod';
+import Database from 'better-sqlite3';
+
+declare const ConfigSchema: z.ZodObject<{
+    cfApiToken: z.ZodOptional<z.ZodString>;
+    cfAccountId: z.ZodOptional<z.ZodString>;
+    cfZoneId: z.ZodOptional<z.ZodString>;
+    emailDomain: z.ZodOptional<z.ZodString>;
+    twilioAccountSid: z.ZodOptional<z.ZodString>;
+    twilioAuthToken: z.ZodOptional<z.ZodString>;
+    lithicApiKey: z.ZodOptional<z.ZodString>;
+    lithicEnvironment: z.ZodDefault<z.ZodEnum<["sandbox", "production"]>>;
+    dbPath: z.ZodDefault<z.ZodString>;
+    logLevel: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+    maxIdentities: z.ZodDefault<z.ZodNumber>;
+    defaultTtlMinutes: z.ZodDefault<z.ZodNumber>;
+    defaultSpendLimitCents: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    lithicEnvironment: "sandbox" | "production";
+    dbPath: string;
+    logLevel: "debug" | "info" | "warn" | "error";
+    maxIdentities: number;
+    defaultTtlMinutes: number;
+    defaultSpendLimitCents: number;
+    cfApiToken?: string | undefined;
+    cfAccountId?: string | undefined;
+    cfZoneId?: string | undefined;
+    emailDomain?: string | undefined;
+    twilioAccountSid?: string | undefined;
+    twilioAuthToken?: string | undefined;
+    lithicApiKey?: string | undefined;
+}, {
+    cfApiToken?: string | undefined;
+    cfAccountId?: string | undefined;
+    cfZoneId?: string | undefined;
+    emailDomain?: string | undefined;
+    twilioAccountSid?: string | undefined;
+    twilioAuthToken?: string | undefined;
+    lithicApiKey?: string | undefined;
+    lithicEnvironment?: "sandbox" | "production" | undefined;
+    dbPath?: string | undefined;
+    logLevel?: "debug" | "info" | "warn" | "error" | undefined;
+    maxIdentities?: number | undefined;
+    defaultTtlMinutes?: number | undefined;
+    defaultSpendLimitCents?: number | undefined;
+}>;
+type TerminatorConfig = z.infer<typeof ConfigSchema>;
+declare function loadConfig(overrides?: Partial<TerminatorConfig>): TerminatorConfig;
+declare function getConfiguredProviders(config: TerminatorConfig): {
+    email: boolean;
+    phone: boolean;
+    card: boolean;
+};
+
+interface Persona {
+    firstName: string;
+    lastName: string;
+    fullName: string;
+    email?: string;
+    phone?: string;
+    address: {
+        line1: string;
+        city: string;
+        state: string;
+        postalCode: string;
+        country: string;
+    };
+}
+declare function createPersona(): Persona;
+
+type IdentityStatus = "created" | "provisioning" | "active" | "killing" | "killed" | "failed";
+type IdentityResources = ("email" | "phone" | "card")[];
+interface Identity {
+    id: string;
+    persona: Persona;
+    status: IdentityStatus;
+    email?: string;
+    emailProviderId?: string;
+    phone?: string;
+    phoneProviderId?: string;
+    cardLastFour?: string;
+    cardProviderId?: string;
+    spendLimitCents?: number;
+    ttlExpiresAt?: string;
+    resources: IdentityResources;
+    createdAt: string;
+    updatedAt: string;
+}
+
+interface EmailInbox {
+    address: string;
+    providerId: string;
+    provider: string;
+}
+interface EmailMessage {
+    id: string;
+    from: string;
+    to: string;
+    subject: string;
+    text: string;
+    html?: string;
+    receivedAt: string;
+}
+interface EmailProvider {
+    name: string;
+    createInbox(identity: Identity): Promise<EmailInbox>;
+    getMessages(inbox: EmailInbox, since?: Date): Promise<EmailMessage[]>;
+    deleteInbox(inbox: EmailInbox): Promise<void>;
+    healthCheck(): Promise<ProviderHealthResult>;
+}
+interface PhoneNumber {
+    number: string;
+    providerId: string;
+    provider: string;
+}
+interface SmsMessage {
+    id: string;
+    from: string;
+    to: string;
+    body: string;
+    receivedAt: string;
+}
+interface PhoneOptions {
+    country?: string;
+    areaCode?: number;
+}
+interface PhoneProvider {
+    name: string;
+    provisionNumber(identity: Identity, options?: PhoneOptions): Promise<PhoneNumber>;
+    getMessages(phone: PhoneNumber, since?: Date): Promise<SmsMessage[]>;
+    releaseNumber(phone: PhoneNumber): Promise<void>;
+    healthCheck(): Promise<ProviderHealthResult>;
+}
+interface VirtualCard {
+    lastFour: string;
+    providerId: string;
+    provider: string;
+}
+interface CardDetails {
+    pan: string;
+    cvv: string;
+    expMonth: number;
+    expYear: number;
+    lastFour: string;
+}
+interface CardOptions {
+    spendLimitCents: number;
+    type?: "single_use" | "reusable";
+}
+interface CardProvider {
+    name: string;
+    createCard(identity: Identity, options: CardOptions): Promise<VirtualCard>;
+    getCardDetails(card: VirtualCard): Promise<CardDetails>;
+    deactivateCard(card: VirtualCard): Promise<void>;
+    healthCheck(): Promise<ProviderHealthResult>;
+}
+interface ProviderHealthResult {
+    provider: string;
+    healthy: boolean;
+    message?: string;
+}
+
+type ActivityEventType = "identity.created" | "identity.provisioning" | "identity.active" | "identity.killing" | "identity.killed" | "identity.failed" | "email.inbox_created" | "email.received" | "email.inbox_deleted" | "phone.provisioned" | "phone.sms_received" | "phone.released" | "card.created" | "card.deactivated" | "policy.violated" | "system.error";
+interface ActivityEvent {
+    id: string;
+    identityId: string | null;
+    timestamp: string;
+    eventType: ActivityEventType;
+    provider: string | null;
+    resourceType: string | null;
+    resourceId: string | null;
+    details: Record<string, unknown> | null;
+    costEstimateCents: number | null;
+}
+declare class ActivityLog {
+    private db;
+    constructor(db: Database.Database);
+    append(event: Omit<ActivityEvent, "id" | "timestamp">): ActivityEvent;
+    query(options?: {
+        identityId?: string;
+        eventType?: ActivityEventType;
+        limit?: number;
+        since?: string;
+    }): ActivityEvent[];
+}
+
+declare class IdentityStore {
+    private db;
+    constructor(db: Database.Database);
+    create(persona: Persona, resources: IdentityResources, options?: {
+        spendLimitCents?: number;
+        ttlMinutes?: number;
+    }): Identity;
+    get(id: string): Identity | null;
+    list(status?: IdentityStatus): Identity[];
+    updateStatus(id: string, newStatus: IdentityStatus): Identity;
+    updateResources(id: string, updates: Partial<Pick<Identity, "email" | "emailProviderId" | "phone" | "phoneProviderId" | "cardLastFour" | "cardProviderId">>): Identity;
+    getExpired(): Identity[];
+    countActive(): number;
+}
+
+interface KillResult {
+    identityId: string;
+    emailRevoked: boolean;
+    phoneRevoked: boolean;
+    cardRevoked: boolean;
+    errors: string[];
+}
+declare class KillSwitch {
+    private identityStore;
+    private activityLog;
+    private emailProvider?;
+    private phoneProvider?;
+    private cardProvider?;
+    constructor(identityStore: IdentityStore, activityLog: ActivityLog, emailProvider?: EmailProvider | undefined, phoneProvider?: PhoneProvider | undefined, cardProvider?: CardProvider | undefined);
+    killIdentity(id: string): Promise<KillResult>;
+    killAll(): Promise<KillResult[]>;
+    private revokeEmail;
+    private revokePhone;
+    private revokeCard;
+}
+
+type PolicyRuleType = "max_identities" | "max_spend_per_identity" | "default_ttl_minutes" | "require_card_approval";
+interface Policy {
+    id: string;
+    name: string;
+    ruleType: PolicyRuleType;
+    ruleValue: unknown;
+    enabled: boolean;
+    createdAt: string;
+}
+declare class PolicyStore {
+    private db;
+    constructor(db: Database.Database);
+    create(name: string, ruleType: PolicyRuleType, ruleValue: unknown): Policy;
+    get(id: string): Policy | null;
+    list(): Policy[];
+    getEnabled(): Policy[];
+    setEnabled(id: string, enabled: boolean): void;
+    delete(id: string): void;
+}
+
+interface PolicyViolation {
+    policy: string;
+    ruleType: string;
+    message: string;
+}
+declare class PolicyEngine {
+    private policyStore;
+    private identityStore;
+    private config;
+    constructor(policyStore: PolicyStore, identityStore: IdentityStore, config: TerminatorConfig);
+    checkCreateIdentity(resources: IdentityResources, spendLimitCents?: number): PolicyViolation[];
+    private evaluateForCreate;
+}
+
+interface TerminatorOptions {
+    config?: Partial<TerminatorConfig>;
+    emailProvider?: EmailProvider;
+    phoneProvider?: PhoneProvider;
+    cardProvider?: CardProvider;
+    inMemory?: boolean;
+}
+interface CreateIdentityOptions {
+    resources?: IdentityResources;
+    spendLimitCents?: number;
+    ttlMinutes?: number;
+    confirm?: boolean;
+}
+declare class Terminator {
+    readonly config: TerminatorConfig;
+    readonly identityStore: IdentityStore;
+    readonly activityLog: ActivityLog;
+    readonly policyStore: PolicyStore;
+    readonly policyEngine: PolicyEngine;
+    readonly killSwitch: KillSwitch;
+    private emailProvider?;
+    private phoneProvider?;
+    private cardProvider?;
+    private db;
+    constructor(options?: TerminatorOptions);
+    createIdentity(options?: CreateIdentityOptions): Promise<Identity>;
+    getIdentity(id: string): Identity | null;
+    listIdentities(status?: "active" | "killed" | "all"): Identity[];
+    readMessages(identityId: string, since?: Date): Promise<{
+        emails: EmailMessage[];
+        sms: SmsMessage[];
+    }>;
+    getCardDetails(identityId: string): Promise<CardDetails>;
+    extractCode(identityId: string): Promise<string | null>;
+    killIdentity(id: string): Promise<KillResult>;
+    killAll(): Promise<KillResult[]>;
+    getActivityLog(options?: {
+        identityId?: string;
+        eventType?: ActivityEventType;
+        limit?: number;
+        since?: string;
+    }): ActivityEvent[];
+    checkStatus(): Promise<{
+        providers: ProviderHealthResult[];
+        activeIdentities: number;
+        configuredProviders: {
+            email: boolean;
+            phone: boolean;
+            card: boolean;
+        };
+    }>;
+    close(): void;
+}
+declare class PolicyViolationError extends Error {
+    violations: PolicyViolation[];
+    constructor(violations: PolicyViolation[]);
+}
+
+declare function canTransition(from: IdentityStatus, to: IdentityStatus): boolean;
+declare function assertTransition(from: IdentityStatus, to: IdentityStatus): void;
+
+declare class MockEmailProvider implements EmailProvider {
+    name: string;
+    private inboxes;
+    createInbox(identity: Identity): Promise<EmailInbox>;
+    getMessages(inbox: EmailInbox, since?: Date): Promise<EmailMessage[]>;
+    deleteInbox(inbox: EmailInbox): Promise<void>;
+    healthCheck(): Promise<ProviderHealthResult>;
+    injectMessage(address: string, message: Omit<EmailMessage, "id" | "receivedAt">): void;
+}
+
+declare class MockPhoneProvider implements PhoneProvider {
+    name: string;
+    private numbers;
+    provisionNumber(_identity: Identity, _options?: PhoneOptions): Promise<PhoneNumber>;
+    getMessages(phone: PhoneNumber, since?: Date): Promise<SmsMessage[]>;
+    releaseNumber(phone: PhoneNumber): Promise<void>;
+    healthCheck(): Promise<ProviderHealthResult>;
+    injectSms(number: string, message: Omit<SmsMessage, "id" | "receivedAt">): void;
+}
+
+declare class MockCardProvider implements CardProvider {
+    name: string;
+    private cards;
+    createCard(_identity: Identity, options: CardOptions): Promise<VirtualCard>;
+    getCardDetails(card: VirtualCard): Promise<CardDetails>;
+    deactivateCard(card: VirtualCard): Promise<void>;
+    healthCheck(): Promise<ProviderHealthResult>;
+}
+
+declare function createDatabase(dbPath: string): Database.Database;
+declare function createInMemoryDatabase(): Database.Database;
+
+interface VerificationCodeResult {
+    code: string;
+    pattern: string;
+}
+declare function parseVerificationCode(text: string): VerificationCodeResult | null;
+
+export { type ActivityEvent, type ActivityEventType, ActivityLog, type CardDetails, type CardOptions, type CardProvider, type CreateIdentityOptions, type EmailInbox, type EmailMessage, type EmailProvider, type Identity, type IdentityResources, type IdentityStatus, IdentityStore, type KillResult, KillSwitch, MockCardProvider, MockEmailProvider, MockPhoneProvider, type Persona, type PhoneNumber, type PhoneOptions, type PhoneProvider, type Policy, PolicyEngine, type PolicyRuleType, PolicyStore, type PolicyViolation, PolicyViolationError, type ProviderHealthResult, type SmsMessage, Terminator, type TerminatorConfig, type TerminatorOptions, type VerificationCodeResult, type VirtualCard, assertTransition, canTransition, createDatabase, createInMemoryDatabase, createPersona, getConfiguredProviders, loadConfig, parseVerificationCode };