@moneysiren/cli 0.1.0-alpha.0

package/dist/packages/config/src/schema.js

@@ -0,0 +1,25 @@
+export const DEFAULT_DB_PATH = ".moneysiren/moneysiren.sqlite";
+export const PROVIDER_ENV_KEYS = {
+    aws: ["AWS_PROFILE"],
+    openai: ["OPENAI_ADMIN_KEY"],
+    supabase: ["SUPABASE_ACCESS_TOKEN"],
+    cloudflare: ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_IDS"],
+    gcp: ["GOOGLE_APPLICATION_CREDENTIALS", "GOOGLE_CLOUD_PROJECT"],
+    azure: ["AZURE_TENANT_ID", "AZURE_CLIENT_ID", "AZURE_CLIENT_SECRET", "AZURE_SUBSCRIPTION_ID"],
+    oracle: ["OCI_CONFIG_FILE", "OCI_PROFILE"],
+    anthropic: ["ANTHROPIC_ADMIN_KEY"],
+    gemini: ["GEMINI_API_KEY", "GOOGLE_APPLICATION_CREDENTIALS", "GOOGLE_CLOUD_PROJECT"],
+    vercel: ["VERCEL_API_TOKEN"],
+    "github-actions": ["GITHUB_TOKEN"],
+    railway: ["RAILWAY_API_TOKEN"],
+    fly: ["FLY_ACCESS_TOKEN"],
+    netlify: ["NETLIFY_AUTH_TOKEN"],
+    render: ["RENDER_API_KEY"],
+    neon: ["NEON_API_KEY"],
+    "mongodb-atlas": ["MONGODB_ATLAS_PUBLIC_KEY", "MONGODB_ATLAS_PRIVATE_KEY", "MONGODB_ATLAS_ORG_ID"],
+    datadog: ["DATADOG_API_KEY", "DATADOG_APP_KEY", "DATADOG_SITE"],
+    sentry: ["SENTRY_AUTH_TOKEN", "SENTRY_ORG"],
+    "codex-cli": [],
+    "claude-cli": [],
+};
+//# sourceMappingURL=schema.js.map

package/dist/packages/connectors/aws/src/cost-explorer.d.ts

@@ -0,0 +1,34 @@
+import type { AwsCostExplorerGetCostAndUsageOutput } from "./normalize.js";
+export interface AwsGetCostAndUsageInput {
+    TimePeriod: {
+        Start: string;
+        End: string;
+    };
+    Granularity: "MONTHLY";
+    Metrics: readonly ["UnblendedCost"];
+    GroupBy: readonly [
+        {
+            Type: "DIMENSION";
+            Key: "SERVICE";
+        }
+    ];
+}
+export interface AwsCostExplorerCommand {
+    name: "GetCostAndUsage";
+    input: AwsGetCostAndUsageInput;
+}
+export interface AwsCostExplorerClientAdapter {
+    send(command: AwsCostExplorerCommand): Promise<AwsCostExplorerGetCostAndUsageOutput>;
+}
+export interface AwsCostExplorerCommandAdapter {
+    createGetCostAndUsageCommand(input: AwsGetCostAndUsageInput): AwsCostExplorerCommand;
+}
+export interface AwsBillingPeriod {
+    start: string;
+    end: string;
+}
+export declare const defaultAwsCostExplorerCommandAdapter: AwsCostExplorerCommandAdapter;
+export declare function createGetCostAndUsageInput(period: AwsBillingPeriod): AwsGetCostAndUsageInput;
+export declare function createCurrentBillingPeriod(now: Date): AwsBillingPeriod;
+export declare function createStaticCostExplorerClient(response: AwsCostExplorerGetCostAndUsageOutput): AwsCostExplorerClientAdapter;
+//# sourceMappingURL=cost-explorer.d.ts.map

package/dist/packages/connectors/aws/src/cost-explorer.js

@@ -0,0 +1,43 @@
+export const defaultAwsCostExplorerCommandAdapter = {
+    createGetCostAndUsageCommand(input) {
+        return {
+            name: "GetCostAndUsage",
+            input,
+        };
+    },
+};
+export function createGetCostAndUsageInput(period) {
+    return {
+        TimePeriod: {
+            Start: period.start,
+            End: period.end,
+        },
+        Granularity: "MONTHLY",
+        Metrics: ["UnblendedCost"],
+        GroupBy: [
+            {
+                Type: "DIMENSION",
+                Key: "SERVICE",
+            },
+        ],
+    };
+}
+export function createCurrentBillingPeriod(now) {
+    const start = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+    const end = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1));
+    return {
+        start: formatAwsDate(start),
+        end: formatAwsDate(end),
+    };
+}
+export function createStaticCostExplorerClient(response) {
+    return {
+        async send() {
+            return response;
+        },
+    };
+}
+function formatAwsDate(date) {
+    return date.toISOString().slice(0, 10);
+}
+//# sourceMappingURL=cost-explorer.js.map

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

@@ -0,0 +1,35 @@
+import { type AwsCostExplorerClientAdapter, type AwsCostExplorerCommandAdapter } from "./cost-explorer.js";
+import { type AwsNormalizedSnapshotBundle } from "./normalize.js";
+export { createCurrentBillingPeriod, createGetCostAndUsageInput, createStaticCostExplorerClient, defaultAwsCostExplorerCommandAdapter, type AwsCostExplorerClientAdapter, type AwsCostExplorerCommand, type AwsCostExplorerCommandAdapter, type AwsGetCostAndUsageInput, } from "./cost-explorer.js";
+export { createAwsSdkCostExplorerClient, type CreateAwsSdkCostExplorerClientOptions, } from "./sdk-client.js";
+export { decimalAmountToMinorUnits, normalizeCostExplorerResponse, type AwsBillingSnapshot, type AwsCostEstimate, type AwsCostExplorerGetCostAndUsageOutput, type AwsCostExplorerGroup, type AwsCostExplorerMetricAmount, type AwsCostExplorerMetrics, type AwsCostExplorerResultByTime, type AwsCostExplorerTimePeriod, type AwsNormalizedSnapshotBundle, type AwsServiceHealthSnapshot, type AwsUsageSnapshot, } from "./normalize.js";
+export interface AwsProviderCollectionContext {
+    now(): Date;
+}
+export interface AwsProviderConnector {
+    kind: "aws";
+    displayName: "AWS Cost Explorer";
+    access: "read-only";
+    collect(context: AwsProviderCollectionContext): Promise<AwsProviderCollectionResult>;
+}
+export interface AwsProviderCollectionResult {
+    collectedAt: string;
+    status: "ok" | "error";
+    snapshots: AwsNormalizedSnapshotBundle;
+    alerts: readonly AwsProviderAlert[];
+    errors?: readonly string[];
+}
+export interface AwsProviderAlert {
+    provider: "aws";
+    createdAt: string;
+    severity: "warning";
+    category: "provider-sync";
+    title: "AWS Cost Explorer sync failed";
+    message: string;
+}
+export interface AwsCostExplorerConnectorOptions {
+    costExplorerClient: AwsCostExplorerClientAdapter;
+    commandAdapter?: AwsCostExplorerCommandAdapter;
+}
+export declare function createAwsCostExplorerConnector(options: AwsCostExplorerConnectorOptions): AwsProviderConnector;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,67 @@
+import { createCurrentBillingPeriod, createGetCostAndUsageInput, defaultAwsCostExplorerCommandAdapter, } from "./cost-explorer.js";
+import { normalizeCostExplorerResponse } from "./normalize.js";
+export { createCurrentBillingPeriod, createGetCostAndUsageInput, createStaticCostExplorerClient, defaultAwsCostExplorerCommandAdapter, } from "./cost-explorer.js";
+export { createAwsSdkCostExplorerClient, } from "./sdk-client.js";
+export { decimalAmountToMinorUnits, normalizeCostExplorerResponse, } from "./normalize.js";
+const EMPTY_AWS_SNAPSHOTS = {
+    usage: [],
+    billing: [],
+    serviceHealth: [],
+    costEstimates: [],
+};
+export function createAwsCostExplorerConnector(options) {
+    const commandAdapter = options.commandAdapter ?? defaultAwsCostExplorerCommandAdapter;
+    return {
+        kind: "aws",
+        displayName: "AWS Cost Explorer",
+        access: "read-only",
+        async collect(context) {
+            const collectedAt = context.now().toISOString();
+            const period = createCurrentBillingPeriod(context.now());
+            const command = commandAdapter.createGetCostAndUsageCommand(createGetCostAndUsageInput(period));
+            try {
+                const response = await options.costExplorerClient.send(command);
+                return {
+                    collectedAt,
+                    status: "ok",
+                    snapshots: normalizeCostExplorerResponse({
+                        response,
+                        collectedAt,
+                    }),
+                    alerts: [],
+                };
+            }
+            catch (caught) {
+                const message = `AWS Cost Explorer request failed: ${safeAwsErrorMessage(caught)}`;
+                return {
+                    collectedAt,
+                    status: "error",
+                    snapshots: EMPTY_AWS_SNAPSHOTS,
+                    alerts: [
+                        {
+                            provider: "aws",
+                            createdAt: collectedAt,
+                            severity: "warning",
+                            category: "provider-sync",
+                            title: "AWS Cost Explorer sync failed",
+                            message,
+                        },
+                    ],
+                    errors: [message],
+                };
+            }
+        },
+    };
+}
+function safeAwsErrorMessage(caught) {
+    const rawMessage = caught instanceof Error && caught.message.trim().length > 0
+        ? caught.message
+        : "unknown AWS SDK error";
+    return rawMessage
+        .replace(/\b(AKIA[A-Z0-9]{16}|ASIA[A-Z0-9]{16})\b/g, "[redacted]")
+        .replace(/\b\d{12}\b/g, "[redacted]")
+        .replace(/\barn:aws[^\s,;)]*/gi, "[redacted]")
+        .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, "[redacted]")
+        .slice(0, 240);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,69 @@
+declare const MONEYSIREN_COST_METRIC = "unblended_cost";
+export interface AwsCostExplorerGetCostAndUsageOutput {
+    ResultsByTime?: readonly AwsCostExplorerResultByTime[];
+}
+export interface AwsCostExplorerResultByTime {
+    TimePeriod?: AwsCostExplorerTimePeriod;
+    Total?: AwsCostExplorerMetrics;
+    Groups?: readonly AwsCostExplorerGroup[];
+    Estimated?: boolean;
+}
+export interface AwsCostExplorerTimePeriod {
+    Start?: string;
+    End?: string;
+}
+export type AwsCostExplorerMetrics = Record<string, AwsCostExplorerMetricAmount | undefined>;
+export interface AwsCostExplorerMetricAmount {
+    Amount?: string;
+    Unit?: string;
+}
+export interface AwsCostExplorerGroup {
+    Keys?: readonly string[];
+    Metrics?: AwsCostExplorerMetrics;
+}
+export interface AwsNormalizedSnapshotBundle {
+    usage: readonly AwsUsageSnapshot[];
+    billing: readonly AwsBillingSnapshot[];
+    serviceHealth: readonly AwsServiceHealthSnapshot[];
+    costEstimates: readonly AwsCostEstimate[];
+}
+export interface AwsUsageSnapshot {
+    provider: "aws";
+    collectedAt: string;
+    service: string;
+    metric: typeof MONEYSIREN_COST_METRIC;
+    unit: string;
+    value: number;
+}
+export interface AwsBillingSnapshot {
+    provider: "aws";
+    collectedAt: string;
+    periodStart: string;
+    periodEnd: string;
+    amountMinor: number;
+    currency: string;
+    status: "estimated" | "final";
+}
+export interface AwsServiceHealthSnapshot {
+    provider: "aws";
+    collectedAt: string;
+    service: string;
+    status: "ok" | "degraded" | "down" | "unknown";
+}
+export interface AwsCostEstimate {
+    provider: "aws";
+    collectedAt: string;
+    periodStart: string;
+    periodEnd: string;
+    estimatedAmountMinor: number;
+    currency: string;
+    confidence: "medium" | "high";
+}
+export interface NormalizeCostExplorerResponseInput {
+    response: AwsCostExplorerGetCostAndUsageOutput;
+    collectedAt: string;
+}
+export declare function normalizeCostExplorerResponse(input: NormalizeCostExplorerResponseInput): AwsNormalizedSnapshotBundle;
+export declare function decimalAmountToMinorUnits(amount: string): number;
+export {};
+//# sourceMappingURL=normalize.d.ts.map

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

@@ -0,0 +1,141 @@
+const UNBLENDED_COST_METRIC = "UnblendedCost";
+const MONEYSIREN_COST_METRIC = "unblended_cost";
+export function normalizeCostExplorerResponse(input) {
+    const usage = [];
+    const billing = [];
+    const costEstimates = [];
+    for (const result of input.response.ResultsByTime ?? []) {
+        const period = requireTimePeriod(result.TimePeriod);
+        const serviceCosts = normalizeServiceCosts(result.Groups ?? []);
+        const totalMetric = readMetric(result.Total, UNBLENDED_COST_METRIC);
+        const currency = totalMetric === undefined
+            ? requireInferredCurrency(serviceCosts)
+            : requireMetricCurrency(totalMetric, "Cost Explorer total");
+        const amountMinor = totalMetric === undefined
+            ? sumMinorUnits(serviceCosts.map((serviceCost) => serviceCost.amountMinor))
+            : decimalAmountToMinorUnits(requireMetricAmount(totalMetric, "Cost Explorer total"));
+        const status = result.Estimated === true ? "estimated" : "final";
+        for (const serviceCost of serviceCosts) {
+            if (serviceCost.unit !== currency) {
+                throw new Error(`Cost Explorer currency mismatch for service ${serviceCost.service}.`);
+            }
+            usage.push({
+                provider: "aws",
+                collectedAt: input.collectedAt,
+                service: serviceCost.service,
+                metric: MONEYSIREN_COST_METRIC,
+                unit: serviceCost.unit,
+                value: serviceCost.amountMinor / 100,
+            });
+        }
+        billing.push({
+            provider: "aws",
+            collectedAt: input.collectedAt,
+            periodStart: period.Start,
+            periodEnd: period.End,
+            amountMinor,
+            currency,
+            status,
+        });
+        costEstimates.push({
+            provider: "aws",
+            collectedAt: input.collectedAt,
+            periodStart: period.Start,
+            periodEnd: period.End,
+            estimatedAmountMinor: amountMinor,
+            currency,
+            confidence: result.Estimated === true ? "medium" : "high",
+        });
+    }
+    return {
+        usage,
+        billing,
+        serviceHealth: [],
+        costEstimates,
+    };
+}
+function normalizeServiceCosts(groups) {
+    return groups.map((group) => {
+        const service = requireServiceName(group);
+        const context = `Cost Explorer service ${service}`;
+        const groupMetric = requireMetric(group.Metrics, UNBLENDED_COST_METRIC, context);
+        return {
+            service,
+            unit: requireMetricCurrency(groupMetric, context),
+            amountMinor: decimalAmountToMinorUnits(requireMetricAmount(groupMetric, context)),
+        };
+    });
+}
+function requireInferredCurrency(serviceCosts) {
+    const currencies = new Set(serviceCosts.map((serviceCost) => serviceCost.unit));
+    if (currencies.size === 0) {
+        throw new Error("Cost Explorer total is missing UnblendedCost and service groups cannot infer a currency.");
+    }
+    if (currencies.size > 1) {
+        throw new Error("Cost Explorer service groups use multiple currencies.");
+    }
+    return [...currencies][0] ?? "USD";
+}
+function sumMinorUnits(amounts) {
+    return amounts.reduce((total, amount) => total + amount, 0);
+}
+export function decimalAmountToMinorUnits(amount) {
+    const trimmed = amount.trim();
+    const sign = trimmed.startsWith("-") ? -1n : 1n;
+    const unsigned = sign === -1n ? trimmed.slice(1) : trimmed;
+    if (!/^\d+(\.\d+)?$/.test(unsigned)) {
+        throw new Error(`AWS currency amount must be a decimal string: ${amount}`);
+    }
+    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(`AWS currency amount is outside safe integer range: ${amount}`);
+    }
+    return asNumber;
+}
+function requireTimePeriod(period) {
+    if (period?.Start === undefined || period.End === undefined) {
+        throw new Error("Cost Explorer result is missing TimePeriod Start or End.");
+    }
+    return {
+        Start: period.Start,
+        End: period.End,
+    };
+}
+function requireMetric(metrics, metricName, context) {
+    const metric = readMetric(metrics, metricName);
+    if (metric === undefined) {
+        throw new Error(`${context} is missing ${metricName}.`);
+    }
+    return metric;
+}
+function readMetric(metrics, metricName) {
+    return metrics?.[metricName];
+}
+function requireMetricAmount(metric, context) {
+    if (metric.Amount === undefined || metric.Amount.trim().length === 0) {
+        throw new Error(`${context} is missing amount.`);
+    }
+    return metric.Amount;
+}
+function requireMetricCurrency(metric, context) {
+    if (metric.Unit === undefined || metric.Unit.trim().length === 0) {
+        throw new Error(`${context} is missing currency unit.`);
+    }
+    return metric.Unit;
+}
+function requireServiceName(group) {
+    const service = group.Keys?.[0]?.trim();
+    if (service === undefined || service.length === 0) {
+        throw new Error("Cost Explorer service group is missing a service key.");
+    }
+    return service;
+}
+//# sourceMappingURL=normalize.js.map

package/dist/packages/connectors/aws/src/sdk-client.d.ts

@@ -0,0 +1,6 @@
+import type { AwsCostExplorerClientAdapter } from "./cost-explorer.js";
+export interface CreateAwsSdkCostExplorerClientOptions {
+    region?: string;
+}
+export declare function createAwsSdkCostExplorerClient(options?: CreateAwsSdkCostExplorerClientOptions): AwsCostExplorerClientAdapter;
+//# sourceMappingURL=sdk-client.d.ts.map

package/dist/packages/connectors/aws/src/sdk-client.js

@@ -0,0 +1,21 @@
+import { CostExplorerClient, GetCostAndUsageCommand } from "@aws-sdk/client-cost-explorer";
+const DEFAULT_COST_EXPLORER_REGION = "us-east-1";
+export function createAwsSdkCostExplorerClient(options = {}) {
+    const region = options.region?.trim() || DEFAULT_COST_EXPLORER_REGION;
+    const client = new CostExplorerClient({ region });
+    return {
+        async send(command) {
+            if (command.name !== "GetCostAndUsage") {
+                throw new Error(`Unsupported AWS Cost Explorer command: ${command.name}`);
+            }
+            const input = {
+                ...command.input,
+                Metrics: [...command.input.Metrics],
+                GroupBy: command.input.GroupBy.map((group) => ({ ...group })),
+            };
+            const output = await client.send(new GetCostAndUsageCommand(input));
+            return output;
+        },
+    };
+}
+//# sourceMappingURL=sdk-client.js.map

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

@@ -0,0 +1,23 @@
+import type { CloudflareBillingUsagePayload } from "./normalize.js";
+export interface CloudflareBillingUsageClient {
+    fetchBillingUsage(): Promise<CloudflareBillingUsagePayload>;
+}
+export type CloudflareApiPath = `/accounts/${string}/billable/usage` | `/accounts/${string}/paygo-usage`;
+export interface CloudflareApiRequest {
+    path: CloudflareApiPath;
+    query: Record<string, string | readonly string[]>;
+    headers: {
+        Authorization: string;
+    };
+}
+export interface CloudflareApiTransport {
+    getJson(request: CloudflareApiRequest): Promise<unknown>;
+}
+export interface CreateCloudflareBillingUsageClientOptions {
+    apiToken: string;
+    accountIds: readonly string[];
+    transport?: CloudflareApiTransport;
+}
+export declare function createCloudflareBillingUsageClient(options: CreateCloudflareBillingUsageClientOptions): CloudflareBillingUsageClient;
+export declare function createStaticCloudflareBillingUsageClient(payload: CloudflareBillingUsagePayload): CloudflareBillingUsageClient;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,107 @@
+const CLOUDFLARE_API_BASE_URL = "https://api.cloudflare.com/client/v4";
+const defaultCloudflareApiTransport = {
+    async getJson(request) {
+        const url = new URL(request.path, CLOUDFLARE_API_BASE_URL);
+        for (const [key, value] of Object.entries(request.query)) {
+            if (isReadonlyStringArray(value)) {
+                for (const nestedValue of value) {
+                    url.searchParams.append(key, nestedValue);
+                }
+                continue;
+            }
+            url.searchParams.set(key, value);
+        }
+        const response = await fetch(url, {
+            method: "GET",
+            headers: request.headers,
+        });
+        if (!response.ok) {
+            throw new Error(`Cloudflare API request failed with status ${response.status}.`);
+        }
+        return response.json();
+    },
+};
+export function createCloudflareBillingUsageClient(options) {
+    const apiToken = options.apiToken.trim();
+    if (apiToken.length === 0) {
+        throw new Error("CLOUDFLARE_API_TOKEN must not be blank.");
+    }
+    const accountIds = [...new Set(options.accountIds.map((accountId) => accountId.trim()).filter(Boolean))];
+    if (accountIds.length === 0) {
+        throw new Error("Cloudflare account IDs must not be empty.");
+    }
+    const transport = options.transport ?? defaultCloudflareApiTransport;
+    return {
+        async fetchBillingUsage() {
+            const headers = {
+                Authorization: `Bearer ${apiToken}`,
+            };
+            const billableUsage = [];
+            const paygoUsage = [];
+            const unavailable = [];
+            for (const accountId of accountIds) {
+                const encodedAccountId = encodeURIComponent(accountId);
+                const billableRecords = await tryFetchSurface(transport, {
+                    path: `/accounts/${encodedAccountId}/billable/usage`,
+                    query: {},
+                    headers,
+                }, unavailable, "billable-usage", accountId);
+                if (billableRecords !== undefined) {
+                    billableUsage.push(...billableRecords);
+                    if (billableRecords.length > 0) {
+                        continue;
+                    }
+                }
+                const paygoRecords = await tryFetchSurface(transport, {
+                    path: `/accounts/${encodedAccountId}/paygo-usage`,
+                    query: {},
+                    headers,
+                }, unavailable, "paygo-usage", accountId);
+                if (paygoRecords !== undefined) {
+                    paygoUsage.push(...paygoRecords);
+                }
+            }
+            return {
+                billableUsage,
+                paygoUsage,
+                unavailable,
+            };
+        },
+    };
+}
+export function createStaticCloudflareBillingUsageClient(payload) {
+    return {
+        async fetchBillingUsage() {
+            return payload;
+        },
+    };
+}
+async function tryFetchSurface(transport, request, unavailable, surface, accountId) {
+    try {
+        return coerceCloudflareResultList(await transport.getJson(request));
+    }
+    catch {
+        unavailable.push({
+            surface,
+            accountId,
+            reason: "restricted-or-unavailable",
+        });
+        return undefined;
+    }
+}
+function coerceCloudflareResultList(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (isRecord(value) && Array.isArray(value.result)) {
+        return value.result;
+    }
+    return [];
+}
+function isReadonlyStringArray(value) {
+    return Array.isArray(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,33 @@
+import { type CloudflareNormalizedSnapshotBundle } from "./normalize.js";
+export { createCloudflareBillingUsageClient, createStaticCloudflareBillingUsageClient, type CloudflareApiPath, type CloudflareApiRequest, type CloudflareApiTransport, type CloudflareBillingUsageClient, type CreateCloudflareBillingUsageClientOptions, } from "./client.js";
+export { cloudflareAmountToMinorUnits, normalizeCloudflareBillingUsage, redactedCloudflareAccountId, type CloudflareAccount, type CloudflareBillableUsageRecord, type CloudflareBillingSnapshot, type CloudflareBillingUsagePayload, type CloudflareCostEstimate, type CloudflareNormalizedSnapshotBundle, type CloudflarePaygoUsageRecord, type CloudflareServiceHealthSnapshot, type CloudflareStatusSignal, type CloudflareUnavailableSurface, type CloudflareUsageSnapshot, type NormalizeCloudflareBillingUsageInput, } from "./normalize.js";
+import type { CloudflareBillingUsageClient } from "./client.js";
+export interface CloudflareProviderCollectionContext {
+    now(): Date;
+}
+export interface CloudflareProviderConnector {
+    kind: "cloudflare";
+    displayName: "Cloudflare Billing/Usage Experimental";
+    access: "read-only";
+    collect(context: CloudflareProviderCollectionContext): Promise<CloudflareProviderCollectionResult>;
+}
+export interface CloudflareProviderCollectionResult {
+    collectedAt: string;
+    status: "ok" | "partial" | "error";
+    snapshots: CloudflareNormalizedSnapshotBundle;
+    alerts: readonly CloudflareProviderAlert[];
+    errors?: readonly string[];
+}
+export interface CloudflareProviderAlert {
+    provider: "cloudflare";
+    createdAt: string;
+    severity: "warning";
+    category: "provider-sync";
+    title: "Cloudflare billing/usage sync failed" | "Cloudflare billable usage surface unavailable" | "Cloudflare PayGo usage surface unavailable" | "Cloudflare subscriptions surface unavailable";
+    message: "Cloudflare billing/usage request failed before normalized snapshots were collected." | "Cloudflare billable usage API was restricted or unavailable; normalized sync continued with available data." | "Cloudflare PayGo usage API was restricted or unavailable; normalized sync continued with available data." | "Cloudflare subscriptions API was restricted or unavailable; normalized sync continued with available data.";
+}
+export interface CloudflareBillingUsageConnectorOptions {
+    client: CloudflareBillingUsageClient;
+}
+export declare function createCloudflareBillingUsageConnector(options: CloudflareBillingUsageConnectorOptions): CloudflareProviderConnector;
+//# sourceMappingURL=index.d.ts.map