@hasna/domains/dist/db/local-store.d.ts

Domain portfolio, registrar, marketplace, and DNS management for AI agents — CLI + MCP + HTTP API + SDK, shared account API and PostgreSQL

/**
 * LocalStore — the sqlite-backed {@link DomainsStore} implementation.
 *
 * FAIL-CLOSED BOUNDARY (hasna/apps fleet-alignment, ruling (d)). `getStore()`
 * never selects this class: `domains` has no local client mode by design and
 * the legacy local-path variables are REFUSED by
 * `lib/client-storage-policy.ts`. LocalStore exists only for explicit sqlite
 * migration/unit fixtures (`src/test/local-store-fixture.test-support.ts`).
 *
 * It lives in its own module, deliberately NOT in `db/store.ts`, so that
 * `bun:sqlite` is unreachable from the CLI, MCP and SDK entrypoints even when
 * a caller pulls the store module through a dynamic `import()` (which defeats
 * per-export tree-shaking by materialising the whole module namespace — that
 * is exactly how `db/database.ts` used to land in `dist/cli/index.js`). Import
 * this module only from tests/fixtures or server-side tooling; importing it
 * from anything reachable by `src/cli/index.ts` or `src/mcp/index.ts` will
 * fail the `no-sqlite-in-client-bundles` ratchet test.
 */
import type { DomainsStore } from "./store.js";
import * as records from "./domain-records.js";
import * as dns from "./dns-records.js";
import * as alertsDb from "./alerts.js";
import * as owners from "./domain-owners.js";
import * as history from "./domain-history.js";
import * as reputation from "./domain-reputation.js";
import type { CreateDomainInput, DomainStatus, ListDomainsOptions, RecordDomainPurchaseInput, UpdateDomainInput, CreateDomainOfferInput, CreateDomainEmailLinkInput } from "./domain-records.js";
import type { DnsRecord, CreateDnsRecordInput, UpdateDnsRecordInput } from "./dns-records.js";
import type { CreateAlertInput } from "./alerts.js";
import type { CreateDomainOwnerInput, DomainOwnerSource } from "./domain-owners.js";
import type { CreateHistoryEntryInput, DomainHistoryType } from "./domain-history.js";
import type { CreateReputationInput } from "./domain-reputation.js";
export declare class LocalStore implements DomainsStore {
    readonly transport: "local";
    createDomain(input: CreateDomainInput): Promise<records.Domain>;
    getDomain(id: string): Promise<records.Domain | null>;
    getDomainByName(name: string): Promise<records.Domain | null>;
    getDomainByIdentifier(identifier: string): Promise<records.Domain | null>;
    getDomainDetails(identifier: string): Promise<records.DomainDetails | null>;
    listDomains(options?: ListDomainsOptions): Promise<records.Domain[]>;
    updateDomain(id: string, input: UpdateDomainInput): Promise<records.Domain | null>;
    deleteDomain(id: string): Promise<boolean>;
    countDomains(): Promise<number>;
    searchDomains(query: string): Promise<records.Domain[]>;
    getByRegistrar(registrar: string): Promise<records.Domain[]>;
    listExpiring(days: number, options?: {
        includeLapsed?: boolean;
    }): Promise<records.Domain[]>;
    listSslExpiring(days: number, options?: {
        includeLapsed?: boolean;
    }): Promise<records.Domain[]>;
    listPastExpiry(): Promise<records.Domain[]>;
    listSslPastExpiry(): Promise<records.Domain[]>;
    getDomainStats(): Promise<records.DomainStats>;
    markDomainPremium(identifier: string, premiumPrice: number, standardPrice?: number): Promise<records.Domain | null>;
    updateDomainLifecycleStatus(identifier: string, status: DomainStatus, notes?: string): Promise<records.Domain | null>;
    recordDomainPurchase(identifier: string, input: RecordDomainPurchaseInput): Promise<records.Domain | null>;
    createDomainOffer(input: CreateDomainOfferInput): Promise<records.DomainOffer>;
    getDomainOffer(id: string): Promise<records.DomainOffer | null>;
    listDomainOffers(domainId: string): Promise<records.DomainOffer[]>;
    linkDomainEmail(input: CreateDomainEmailLinkInput): Promise<records.DomainEmailLink>;
    getDomainEmailLink(id: string): Promise<records.DomainEmailLink | null>;
    listDomainEmailLinks(domainId: string): Promise<records.DomainEmailLink[]>;
    createDnsRecord(input: CreateDnsRecordInput): Promise<dns.DnsRecord>;
    getDnsRecord(id: string): Promise<dns.DnsRecord | null>;
    listDnsRecords(domainId: string, type?: DnsRecord["type"]): Promise<dns.DnsRecord[]>;
    updateDnsRecord(id: string, input: UpdateDnsRecordInput): Promise<dns.DnsRecord | null>;
    deleteDnsRecord(id: string): Promise<boolean>;
    createAlert(input: CreateAlertInput): Promise<alertsDb.Alert>;
    getAlert(id: string): Promise<alertsDb.Alert | null>;
    listAlerts(domainId: string): Promise<alertsDb.Alert[]>;
    deleteAlert(id: string): Promise<boolean>;
    createDomainOwner(input: CreateDomainOwnerInput): Promise<owners.DomainOwner>;
    getDomainOwner(id: string): Promise<owners.DomainOwner | null>;
    getDomainOwnerByDomain(domainId: string): Promise<owners.DomainOwner | null>;
    getDomainOwnerByDomainName(domainName: string): Promise<owners.DomainOwner | null>;
    listDomainOwners(options?: {
        search?: string;
        source?: DomainOwnerSource;
        verified?: boolean;
    }): Promise<owners.DomainOwner[]>;
    updateDomainOwner(id: string, input: Partial<CreateDomainOwnerInput>): Promise<owners.DomainOwner | null>;
    deleteDomainOwner(id: string): Promise<boolean>;
    listDomainsWithOwners(): Promise<owners.DomainWithOwner[]>;
    createHistoryEntry(input: CreateHistoryEntryInput): Promise<history.DomainHistory>;
    getHistoryEntry(id: string): Promise<history.DomainHistory | null>;
    getHistoryByDomain(domainId: string, options?: {
        type?: DomainHistoryType;
        limit?: number;
    }): Promise<history.DomainHistory[]>;
    getLatestSnapshot(domainId: string, type: DomainHistoryType): Promise<history.DomainHistory | null>;
    getHistoryByDateRange(startDate: string, endDate: string, domainId?: string): Promise<history.DomainHistory[]>;
    listDomainsWithHistoryChanges(): Promise<{
        domain_id: string;
        domain_name: string;
        latest_snapshot_type: string;
        latest_snapshot_at: string;
        snapshot_count: number;
    }[]>;
    deleteHistoryEntry(id: string): Promise<boolean>;
    deleteHistoryByDomain(domainId: string): Promise<boolean>;
    upsertDomainReputation(input: CreateReputationInput): Promise<reputation.DomainReputation>;
    getDomainReputation(domainId: string): Promise<reputation.DomainReputation | null>;
    getDomainReputationByName(domainName: string): Promise<reputation.DomainReputation | null>;
    updateDomainReputation(id: string, input: Partial<CreateReputationInput>): Promise<reputation.DomainReputation | null>;
    listBlacklistedDomains(): Promise<reputation.DomainReputation[]>;
    listHighThreatDomains(threshold?: number): Promise<reputation.DomainReputation[]>;
    deleteDomainReputation(id: string): Promise<boolean>;
}
//# sourceMappingURL=local-store.d.ts.map