@moneysiren/app 0.1.0-alpha.10

package/dist/packages/connectors/cloudflare/src/index.js

@@ -0,0 +1,81 @@
+import { normalizeCloudflareBillingUsage, } from "./normalize.js";
+export { createCloudflareBillingUsageClient, createStaticCloudflareBillingUsageClient, } from "./client.js";
+export { cloudflareAmountToMinorUnits, normalizeCloudflareBillingUsage, redactedCloudflareAccountId, } from "./normalize.js";
+const EMPTY_CLOUDFLARE_SNAPSHOTS = {
+    usage: [],
+    billing: [],
+    serviceHealth: [],
+    costEstimates: [],
+};
+export function createCloudflareBillingUsageConnector(options) {
+    return {
+        kind: "cloudflare",
+        displayName: "Cloudflare Billing/Usage Experimental",
+        access: "read-only",
+        async collect(context) {
+            const collectedAt = context.now().toISOString();
+            try {
+                const payload = await options.client.fetchBillingUsage();
+                const alerts = unavailableSurfaceAlerts(payload.unavailable ?? [], collectedAt);
+                return {
+                    collectedAt,
+                    status: alerts.length === 0 ? "ok" : "partial",
+                    snapshots: normalizeCloudflareBillingUsage({
+                        payload,
+                        collectedAt,
+                    }),
+                    alerts,
+                    ...(alerts.length === 0 ? {} : { errors: alerts.map((alert) => alert.message) }),
+                };
+            }
+            catch {
+                return {
+                    collectedAt,
+                    status: "error",
+                    snapshots: EMPTY_CLOUDFLARE_SNAPSHOTS,
+                    alerts: [
+                        {
+                            provider: "cloudflare",
+                            createdAt: collectedAt,
+                            severity: "warning",
+                            category: "provider-sync",
+                            title: "Cloudflare billing/usage sync failed",
+                            message: "Cloudflare billing/usage request failed before normalized snapshots were collected.",
+                        },
+                    ],
+                    errors: ["Cloudflare billing/usage request failed."],
+                };
+            }
+        },
+    };
+}
+function unavailableSurfaceAlerts(surfaces, collectedAt) {
+    const uniqueSurfaces = new Set(surfaces.map((surface) => surface.surface));
+    return [...uniqueSurfaces].sort().map((surface) => ({
+        provider: "cloudflare",
+        createdAt: collectedAt,
+        severity: "warning",
+        category: "provider-sync",
+        title: unavailableSurfaceTitle(surface),
+        message: unavailableSurfaceMessage(surface),
+    }));
+}
+function unavailableSurfaceTitle(surface) {
+    if (surface === "billable-usage") {
+        return "Cloudflare billable usage surface unavailable";
+    }
+    if (surface === "paygo-usage") {
+        return "Cloudflare PayGo usage surface unavailable";
+    }
+    return "Cloudflare subscriptions surface unavailable";
+}
+function unavailableSurfaceMessage(surface) {
+    if (surface === "billable-usage") {
+        return "Cloudflare billable usage API was restricted or unavailable; normalized sync continued with available data.";
+    }
+    if (surface === "paygo-usage") {
+        return "Cloudflare PayGo usage API was restricted or unavailable; normalized sync continued with available data.";
+    }
+    return "Cloudflare subscriptions API was restricted or unavailable; normalized sync continued with available data.";
+}
+//# sourceMappingURL=index.js.map

package/dist/packages/connectors/cloudflare/src/normalize.d.ts

@@ -0,0 +1,113 @@
+declare const CLOUDFLARE_PROVIDER = "cloudflare";
+export interface CloudflareBillingUsagePayload {
+    accounts?: readonly CloudflareAccount[];
+    billableUsage?: readonly CloudflareBillableUsageRecord[];
+    paygoUsage?: readonly CloudflarePaygoUsageRecord[];
+    status?: readonly CloudflareStatusSignal[];
+    unavailable?: readonly CloudflareUnavailableSurface[];
+}
+export interface CloudflareAccount {
+    id?: string;
+    name?: string;
+}
+export interface CloudflareBillableUsageRecord {
+    BillingAccountId?: string;
+    BillingAccountName?: string;
+    BillingCurrency?: string;
+    BillingPeriodStart?: string;
+    BillingPeriodEnd?: string;
+    ChargePeriodStart?: string;
+    ChargePeriodEnd?: string;
+    BilledCost?: number | string;
+    Cost?: number | string;
+    ConsumedQuantity?: number | string;
+    ConsumedUnit?: string;
+    PricingQuantity?: number | string;
+    PricingUnit?: string;
+    ServiceName?: string;
+    x_ProductFamilyName?: string;
+    x_BillableMetricId?: string;
+    x_ZoneId?: string;
+    x_ZoneName?: string;
+    SubAccountId?: string;
+    SubAccountName?: string;
+    ChargeCategory?: string;
+    ChargeDescription?: string;
+    ChargeFrequency?: string;
+}
+export interface CloudflarePaygoUsageRecord {
+    BillingAccountId?: string;
+    BillingCurrency?: string;
+    BillingPeriodStart?: string;
+    BillingPeriodEnd?: string;
+    ChargePeriodStart?: string;
+    ChargePeriodEnd?: string;
+    ContractedCost?: number | string;
+    CumulatedContractedCost?: number | string;
+    ConsumedQuantity?: number | string;
+    ConsumedUnit?: string;
+    ServiceName?: string;
+    ServiceFamilyName?: string;
+}
+export interface CloudflareStatusSignal {
+    accountId?: string;
+    service?: string;
+    status?: string;
+    message?: string;
+}
+export interface CloudflareUnavailableSurface {
+    surface: "billable-usage" | "paygo-usage" | "subscriptions";
+    accountId?: string;
+    reason?: string;
+}
+export interface CloudflareNormalizedSnapshotBundle {
+    usage: readonly CloudflareUsageSnapshot[];
+    billing: readonly CloudflareBillingSnapshot[];
+    serviceHealth: readonly CloudflareServiceHealthSnapshot[];
+    costEstimates: readonly CloudflareCostEstimate[];
+}
+export interface CloudflareUsageSnapshot {
+    provider: typeof CLOUDFLARE_PROVIDER;
+    collectedAt: string;
+    providerAccountRef: string;
+    service: string;
+    metric: "billable_quantity";
+    unit: string;
+    value: number;
+}
+export interface CloudflareBillingSnapshot {
+    provider: typeof CLOUDFLARE_PROVIDER;
+    collectedAt: string;
+    providerAccountRef: string;
+    periodStart: string;
+    periodEnd: string;
+    amountMinor: number;
+    currency: string;
+    status: "estimated";
+}
+export interface CloudflareServiceHealthSnapshot {
+    provider: typeof CLOUDFLARE_PROVIDER;
+    collectedAt: string;
+    service: string;
+    status: "ok" | "degraded" | "down" | "unknown";
+    message?: string;
+}
+export interface CloudflareCostEstimate {
+    provider: typeof CLOUDFLARE_PROVIDER;
+    collectedAt: string;
+    providerAccountRef: string;
+    periodStart: string;
+    periodEnd: string;
+    estimatedAmountMinor: number;
+    currency: string;
+    confidence: "low";
+}
+export interface NormalizeCloudflareBillingUsageInput {
+    payload: CloudflareBillingUsagePayload;
+    collectedAt: string;
+}
+export declare function normalizeCloudflareBillingUsage(input: NormalizeCloudflareBillingUsageInput): CloudflareNormalizedSnapshotBundle;
+export declare function redactedCloudflareAccountId(accountId: string): string;
+export declare function cloudflareAmountToMinorUnits(amount: number | string): number;
+export {};
+//# sourceMappingURL=normalize.d.ts.map

package/dist/packages/connectors/cloudflare/src/normalize.js

@@ -0,0 +1,288 @@
+import { createHash } from "node:crypto";
+const CLOUDFLARE_PROVIDER = "cloudflare";
+const ACCOUNT_ID_HASH_PREFIX = "cloudflare-account";
+export function normalizeCloudflareBillingUsage(input) {
+    const chargeRecords = normalizeChargeRecords(input.payload);
+    return {
+        usage: chargeRecords.map((record) => ({
+            provider: CLOUDFLARE_PROVIDER,
+            collectedAt: input.collectedAt,
+            providerAccountRef: record.providerAccountRef,
+            service: `${record.service}:${record.providerAccountRef}`,
+            metric: "billable_quantity",
+            unit: record.unit,
+            value: record.quantity,
+        })),
+        billing: normalizeBilling(chargeRecords, input.collectedAt),
+        serviceHealth: normalizeHealth(input.payload, input.collectedAt),
+        costEstimates: normalizeCostEstimates(chargeRecords, input.collectedAt),
+    };
+}
+export function redactedCloudflareAccountId(accountId) {
+    const trimmedAccountId = requireNonBlankString(accountId, "Cloudflare account ID");
+    const digest = createHash("sha256").update(`cloudflare:${trimmedAccountId}`).digest("hex").slice(0, 16);
+    return `${ACCOUNT_ID_HASH_PREFIX}:${digest}`;
+}
+export function cloudflareAmountToMinorUnits(amount) {
+    const rawAmount = typeof amount === "number" ? String(requireFiniteNumber(amount, "Cloudflare cost amount")) : amount;
+    const trimmed = rawAmount.trim();
+    const sign = trimmed.startsWith("-") ? -1n : 1n;
+    const unsigned = sign === -1n ? trimmed.slice(1) : trimmed;
+    if (!/^\d+(\.\d+)?$/.test(unsigned)) {
+        throw new Error(`Cloudflare currency amount must be a decimal string or finite number: ${rawAmount}`);
+    }
+    const [wholePart = "0", fractionPart = ""] = unsigned.split(".");
+    const minorDigits = `${fractionPart}00`.slice(0, 2);
+    const roundingDigit = Number(`${fractionPart}000`.slice(2, 3));
+    let minorUnits = BigInt(wholePart) * 100n + BigInt(minorDigits);
+    if (roundingDigit >= 5) {
+        minorUnits += 1n;
+    }
+    const signedMinorUnits = minorUnits * sign;
+    const asNumber = Number(signedMinorUnits);
+    if (!Number.isSafeInteger(asNumber)) {
+        throw new Error(`Cloudflare currency amount is outside safe integer range: ${rawAmount}`);
+    }
+    return asNumber;
+}
+function normalizeChargeRecords(payload) {
+    const billableUsage = payload.billableUsage ?? [];
+    const paygoUsage = payload.paygoUsage ?? [];
+    if (billableUsage.length === 0) {
+        return paygoUsage.map(normalizePaygoUsageRecord);
+    }
+    const billableAccountIds = new Set(billableUsage
+        .map((record) => readOptionalNonBlankString(record.BillingAccountId))
+        .filter((accountId) => accountId !== undefined));
+    const paygoFallbackUsage = paygoUsage.filter((record) => {
+        const accountId = readOptionalNonBlankString(record.BillingAccountId);
+        return accountId === undefined || !billableAccountIds.has(accountId);
+    });
+    return [
+        ...billableUsage.map(normalizeBillableUsageRecord),
+        ...paygoFallbackUsage.map(normalizePaygoUsageRecord),
+    ];
+}
+function normalizeBillableUsageRecord(record) {
+    const accountRef = redactedCloudflareAccountId(requireNonBlankString(record.BillingAccountId, "BillingAccountId"));
+    const service = normalizeServiceName(readOptionalNonBlankString(record.x_ProductFamilyName) ??
+        readOptionalNonBlankString(record.ServiceName) ??
+        "Cloudflare usage");
+    const unit = readOptionalNonBlankString(record.PricingUnit) ??
+        readOptionalNonBlankString(record.ConsumedUnit) ??
+        "units";
+    const currency = readOptionalNonBlankString(record.BillingCurrency)?.toUpperCase();
+    const amountMinor = optionalAmountToMinorUnits(record.BilledCost ?? record.Cost);
+    return {
+        providerAccountRef: accountRef,
+        service,
+        unit,
+        quantity: readOptionalFiniteNumber(record.PricingQuantity, `${service} PricingQuantity`) ??
+            readOptionalFiniteNumber(record.ConsumedQuantity, `${service} ConsumedQuantity`) ??
+            0,
+        periodStart: normalizePeriodDate(readOptionalNonBlankString(record.ChargePeriodStart) ??
+            readOptionalNonBlankString(record.BillingPeriodStart), "Cloudflare billable usage period start"),
+        periodEnd: normalizePeriodDate(readOptionalNonBlankString(record.ChargePeriodEnd) ??
+            readOptionalNonBlankString(record.BillingPeriodEnd), "Cloudflare billable usage period end"),
+        ...(currency === undefined ? {} : { currency }),
+        ...(amountMinor === undefined ? {} : { amountMinor }),
+    };
+}
+function normalizePaygoUsageRecord(record) {
+    const accountRef = redactedCloudflareAccountId(requireNonBlankString(record.BillingAccountId, "BillingAccountId"));
+    const service = normalizeServiceName(readOptionalNonBlankString(record.ServiceName) ??
+        readOptionalNonBlankString(record.ServiceFamilyName) ??
+        "Cloudflare PayGo usage");
+    const unit = readOptionalNonBlankString(record.ConsumedUnit) ?? "units";
+    const currency = readOptionalNonBlankString(record.BillingCurrency)?.toUpperCase();
+    const amountMinor = optionalAmountToMinorUnits(record.ContractedCost);
+    return {
+        providerAccountRef: accountRef,
+        service,
+        unit,
+        quantity: readOptionalFiniteNumber(record.ConsumedQuantity, `${service} ConsumedQuantity`) ?? 0,
+        periodStart: normalizePeriodDate(readOptionalNonBlankString(record.ChargePeriodStart) ??
+            readOptionalNonBlankString(record.BillingPeriodStart), "Cloudflare PayGo usage period start"),
+        periodEnd: normalizePeriodDate(readOptionalNonBlankString(record.ChargePeriodEnd) ??
+            readOptionalNonBlankString(record.BillingPeriodEnd), "Cloudflare PayGo usage period end"),
+        ...(currency === undefined ? {} : { currency }),
+        ...(amountMinor === undefined ? {} : { amountMinor }),
+    };
+}
+function normalizeBilling(records, collectedAt) {
+    return aggregateBillingRecords(records).map((record) => ({
+        provider: CLOUDFLARE_PROVIDER,
+        collectedAt,
+        providerAccountRef: record.providerAccountRef,
+        periodStart: record.periodStart,
+        periodEnd: record.periodEnd,
+        amountMinor: record.amountMinor,
+        currency: record.currency,
+        status: "estimated",
+    }));
+}
+function normalizeCostEstimates(records, collectedAt) {
+    return aggregateBillingRecords(records).map((record) => ({
+        provider: CLOUDFLARE_PROVIDER,
+        collectedAt,
+        providerAccountRef: record.providerAccountRef,
+        periodStart: record.periodStart,
+        periodEnd: record.periodEnd,
+        estimatedAmountMinor: record.amountMinor,
+        currency: record.currency,
+        confidence: "low",
+    }));
+}
+function aggregateBillingRecords(records) {
+    const accumulators = new Map();
+    for (const record of records) {
+        if (record.amountMinor === undefined || record.currency === undefined) {
+            continue;
+        }
+        const key = [
+            record.providerAccountRef,
+            record.periodStart,
+            record.periodEnd,
+            record.currency,
+        ].join("|");
+        const existing = accumulators.get(key);
+        if (existing === undefined) {
+            accumulators.set(key, {
+                providerAccountRef: record.providerAccountRef,
+                periodStart: record.periodStart,
+                periodEnd: record.periodEnd,
+                currency: record.currency,
+                amountMinor: record.amountMinor,
+            });
+            continue;
+        }
+        existing.amountMinor += record.amountMinor;
+    }
+    return [...accumulators.values()].sort((left, right) => `${left.periodStart}:${left.providerAccountRef}:${left.currency}`.localeCompare(`${right.periodStart}:${right.providerAccountRef}:${right.currency}`));
+}
+function normalizeHealth(payload, collectedAt) {
+    const snapshots = [];
+    const seen = new Set();
+    for (const signal of payload.status ?? []) {
+        const accountId = readOptionalNonBlankString(signal.accountId);
+        const service = normalizeHealthServiceName(readOptionalNonBlankString(signal.service));
+        if (accountId === undefined) {
+            continue;
+        }
+        pushHealthSnapshot(snapshots, seen, {
+            provider: CLOUDFLARE_PROVIDER,
+            collectedAt,
+            service: `${service}:${redactedCloudflareAccountId(accountId)}`,
+            status: mapCloudflareStatus(readOptionalNonBlankString(signal.status)),
+            message: safeStatusMessage(readOptionalNonBlankString(signal.status)),
+        });
+    }
+    for (const unavailable of payload.unavailable ?? []) {
+        const accountId = readOptionalNonBlankString(unavailable.accountId);
+        if (accountId === undefined) {
+            continue;
+        }
+        pushHealthSnapshot(snapshots, seen, {
+            provider: CLOUDFLARE_PROVIDER,
+            collectedAt,
+            service: `${surfaceServiceName(unavailable.surface)}:${redactedCloudflareAccountId(accountId)}`,
+            status: "degraded",
+            message: "Cloudflare billing usage API unavailable for this account.",
+        });
+    }
+    return snapshots;
+}
+function pushHealthSnapshot(snapshots, seen, snapshot) {
+    if (seen.has(snapshot.service)) {
+        return;
+    }
+    seen.add(snapshot.service);
+    snapshots.push(snapshot);
+}
+function normalizeServiceName(serviceName) {
+    return serviceName.replaceAll(/\s+/g, " ").trim();
+}
+function normalizeHealthServiceName(serviceName) {
+    return serviceName?.replaceAll(/[^a-z0-9]+/gi, "_").replaceAll(/^_+|_+$/g, "").toLowerCase() ??
+        "billing_usage_api";
+}
+function surfaceServiceName(surface) {
+    if (surface === "billable-usage") {
+        return "billable_usage_api";
+    }
+    if (surface === "paygo-usage") {
+        return "paygo_usage_api";
+    }
+    return "subscriptions_api";
+}
+function mapCloudflareStatus(status) {
+    const normalized = status?.trim().toLowerCase();
+    if (normalized === "ok" || normalized === "available" || normalized === "healthy" || normalized === "active") {
+        return "ok";
+    }
+    if (normalized === "restricted" ||
+        normalized === "unavailable" ||
+        normalized === "degraded" ||
+        normalized === "limited") {
+        return "degraded";
+    }
+    if (normalized === "down" || normalized === "error" || normalized === "failed") {
+        return "down";
+    }
+    return "unknown";
+}
+function safeStatusMessage(status) {
+    const mappedStatus = mapCloudflareStatus(status);
+    if (mappedStatus === "ok") {
+        return "Cloudflare billing usage API available.";
+    }
+    if (mappedStatus === "unknown") {
+        return "Cloudflare billing usage API status unknown.";
+    }
+    return "Cloudflare billing usage API unavailable for this account.";
+}
+function normalizePeriodDate(value, context) {
+    const trimmed = requireNonBlankString(value, context);
+    const isoDate = /^\d{4}-\d{2}-\d{2}/.exec(trimmed)?.[0];
+    if (isoDate === undefined) {
+        throw new Error(`${context} must start with an ISO date.`);
+    }
+    return isoDate;
+}
+function optionalAmountToMinorUnits(amount) {
+    if (amount === undefined) {
+        return undefined;
+    }
+    return cloudflareAmountToMinorUnits(amount);
+}
+function readOptionalFiniteNumber(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "number") {
+        return requireFiniteNumber(value, context);
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    return requireFiniteNumber(Number(trimmed), context);
+}
+function requireFiniteNumber(value, context) {
+    if (!Number.isFinite(value)) {
+        throw new Error(`${context} must be finite.`);
+    }
+    return value;
+}
+function requireNonBlankString(value, context) {
+    const trimmed = value?.trim();
+    if (trimmed === undefined || trimmed.length === 0) {
+        throw new Error(`${context} must not be blank.`);
+    }
+    return trimmed;
+}
+function readOptionalNonBlankString(value) {
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed.length === 0 ? undefined : trimmed;
+}
+//# sourceMappingURL=normalize.js.map

package/dist/packages/connectors/mock/src/index.d.ts

@@ -0,0 +1,58 @@
+export type MockProviderSnapshot = {
+    provider: "mock";
+    collectedAt: string;
+    status: "ok";
+};
+export interface MockProviderCollectionContext {
+    now(): Date;
+}
+export interface MockProviderConnector {
+    kind: "mock";
+    displayName: "Mock Provider";
+    access: "read-only";
+    collect(context: MockProviderCollectionContext): Promise<MockProviderCollectionResult>;
+}
+export interface MockProviderCollectionResult {
+    collectedAt: string;
+    status: "ok";
+    snapshots: {
+        usage: readonly MockUsageSnapshot[];
+        billing: readonly MockBillingSnapshot[];
+        serviceHealth: readonly MockServiceHealthSnapshot[];
+        costEstimates: readonly MockCostEstimate[];
+    };
+    alerts: readonly [];
+}
+export interface MockSnapshotBase {
+    provider: "mock";
+    collectedAt: string;
+    service?: string;
+}
+export interface MockUsageSnapshot extends MockSnapshotBase {
+    service: "mock-api";
+    metric: "requests";
+    unit: "count";
+    value: 1200;
+}
+export interface MockBillingSnapshot extends MockSnapshotBase {
+    periodStart: string;
+    periodEnd: string;
+    amountMinor: 1234;
+    currency: "USD";
+    status: "estimated";
+}
+export interface MockServiceHealthSnapshot extends MockSnapshotBase {
+    service: "mock-api";
+    region: "local";
+    status: "ok";
+}
+export interface MockCostEstimate extends MockSnapshotBase {
+    periodStart: string;
+    periodEnd: string;
+    estimatedAmountMinor: 1500;
+    currency: "USD";
+    confidence: "high";
+}
+export declare function createMockSnapshot(collectedAt?: string): MockProviderSnapshot;
+export declare function createMockProviderConnector(): MockProviderConnector;
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/connectors/mock/src/index.js

@@ -0,0 +1,66 @@
+export function createMockSnapshot(collectedAt = new Date().toISOString()) {
+    return {
+        provider: "mock",
+        collectedAt,
+        status: "ok",
+    };
+}
+export function createMockProviderConnector() {
+    return {
+        kind: "mock",
+        displayName: "Mock Provider",
+        access: "read-only",
+        async collect(context) {
+            const collectedAt = context.now().toISOString();
+            return {
+                collectedAt,
+                status: "ok",
+                snapshots: {
+                    usage: [
+                        {
+                            provider: "mock",
+                            collectedAt,
+                            service: "mock-api",
+                            metric: "requests",
+                            unit: "count",
+                            value: 1200,
+                        },
+                    ],
+                    billing: [
+                        {
+                            provider: "mock",
+                            collectedAt,
+                            periodStart: "2026-06-01",
+                            periodEnd: "2026-06-30",
+                            amountMinor: 1234,
+                            currency: "USD",
+                            status: "estimated",
+                        },
+                    ],
+                    serviceHealth: [
+                        {
+                            provider: "mock",
+                            collectedAt,
+                            service: "mock-api",
+                            region: "local",
+                            status: "ok",
+                        },
+                    ],
+                    costEstimates: [
+                        {
+                            provider: "mock",
+                            collectedAt,
+                            periodStart: "2026-06-01",
+                            periodEnd: "2026-06-30",
+                            estimatedAmountMinor: 1500,
+                            currency: "USD",
+                            confidence: "high",
+                        },
+                    ],
+                },
+                alerts: [],
+            };
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/packages/connectors/openai/src/index.d.ts

@@ -0,0 +1,55 @@
+import { type OpenAiNormalizedSnapshotBundle, type OpenAiUsageCostsPayload } from "./normalize.js";
+export { normalizeOpenAiUsageCosts, openAiAmountToMinorUnits, type OpenAiBillingSnapshot, type OpenAiCostAmount, type OpenAiCostEstimate, type OpenAiCostsBucket, type OpenAiCostsPage, type OpenAiCostsResult, type OpenAiNormalizedSnapshotBundle, type OpenAiServiceHealthSnapshot, type OpenAiUsageBucket, type OpenAiUsageCostsPayload, type OpenAiUsagePage, type OpenAiUsageResult, type OpenAiUsageSnapshot, } from "./normalize.js";
+export interface OpenAiUsageCostsPeriod {
+    startTime: number;
+    endTime: number;
+}
+export interface OpenAiUsageCostsClient {
+    fetchUsageCosts(period: OpenAiUsageCostsPeriod): Promise<OpenAiUsageCostsPayload>;
+}
+export interface OpenAiUsageCostsRequest {
+    path: "/v1/organization/usage/completions" | "/v1/organization/costs";
+    query: Record<string, string | readonly string[]>;
+    headers: {
+        Authorization: string;
+    };
+}
+export interface OpenAiUsageCostsTransport {
+    getJson(request: OpenAiUsageCostsRequest): Promise<unknown>;
+}
+export interface CreateOpenAiUsageCostsClientOptions {
+    adminKey: string;
+    transport?: OpenAiUsageCostsTransport;
+}
+export interface OpenAiProviderCollectionContext {
+    now(): Date;
+}
+export interface OpenAiProviderConnector {
+    kind: "openai";
+    displayName: "OpenAI Usage/Costs";
+    access: "read-only";
+    collect(context: OpenAiProviderCollectionContext): Promise<OpenAiProviderCollectionResult>;
+}
+export interface OpenAiProviderCollectionResult {
+    collectedAt: string;
+    status: "ok" | "error";
+    snapshots: OpenAiNormalizedSnapshotBundle;
+    alerts: readonly OpenAiProviderAlert[];
+    errors?: readonly string[];
+}
+export interface OpenAiProviderAlert {
+    provider: "openai";
+    createdAt: string;
+    severity: "warning";
+    category: "provider-sync";
+    title: "OpenAI Usage/Costs sync failed";
+    message: "OpenAI Usage/Costs request failed before normalized snapshots were collected.";
+}
+export interface OpenAiUsageCostsConnectorOptions {
+    client: OpenAiUsageCostsClient;
+}
+export declare function createOpenAiUsageCostsClient(options: CreateOpenAiUsageCostsClientOptions): OpenAiUsageCostsClient;
+export declare function createStaticOpenAiUsageCostsClient(payload: OpenAiUsageCostsPayload): OpenAiUsageCostsClient;
+export declare function createOpenAiUsageCostsConnector(options: OpenAiUsageCostsConnectorOptions): OpenAiProviderConnector;
+export declare function createCurrentOpenAiUsageCostsPeriod(now: Date): OpenAiUsageCostsPeriod;
+//# sourceMappingURL=index.d.ts.map