import { quotaSnapshotResource, type QuotaSnapshotRow } from '@undefineds.co/models';
import type { AuthContext } from '../../auth/AuthContext';
import type { GatewayDeployment } from '../auth/InvocationTokenCodec';
import type { InternalPodAccessTokenProvider } from '../pod/HostedPodDataAccess';
import { type PodBaseUrlResolver } from '../pod/PodBaseUrlResolver';
import type { ConnectCredentialRecord, PodCredentialRepository } from '../connect';
import type { CredentialVault, ProviderSecret } from '../credentials/CredentialVault';
import type { ProviderRegistry } from '../providers/ProviderRegistry';
import { type QuotaHandlerCapability } from './QuotaCapabilityRegistry';
import { ProviderHttpTransport } from '../../service/provider-http-transport';
export type QuotaSnapshotStatus = 'available' | 'unsupported' | 'error';
export interface QuotaWindow {
    name: string;
    used?: number;
    usedExact?: string;
    limit?: number;
    limitExact?: string;
    remaining?: number;
    remainingExact?: string;
    displayApprox?: boolean;
    currency?: string;
    resetsAt?: string;
}
export interface NormalizedQuotaSnapshot {
    id?: string;
    credential: string;
    status: QuotaSnapshotStatus;
    balance?: number;
    windows: QuotaWindow[];
    observedAt: string;
    expiresAt: string;
    source: string;
    stale?: boolean;
    metadata?: Record<string, unknown>;
}
export interface QuotaCredentialRecord extends ConnectCredentialRecord {
    baseUrl?: string;
    proxyUrl?: string;
    offeringId?: string;
}
export interface ProviderQuotaFetchInput {
    credential: QuotaCredentialRecord;
    secret: ProviderSecret;
    now: Date;
    signal?: AbortSignal;
}
export interface ProviderQuotaAdapter {
    readonly provider: string;
    readonly capability?: QuotaHandlerCapability;
    supports?(credential: QuotaCredentialRecord): boolean;
    fetch(input: ProviderQuotaFetchInput): Promise<NormalizedQuotaSnapshot>;
}
export interface QuotaSnapshotRepository {
    findFresh(input: {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
        credentialIri: string;
        now: Date;
        auth?: AuthContext;
    }): Promise<NormalizedQuotaSnapshot | undefined>;
    findLatest(input: {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
        credentialIri: string;
        auth?: AuthContext;
    }): Promise<NormalizedQuotaSnapshot | undefined>;
    upsert(input: {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
        snapshot: NormalizedQuotaSnapshot;
        auth?: AuthContext;
    }): Promise<NormalizedQuotaSnapshot>;
}
export interface ProviderQuotaStatusInput {
    webId: string;
    deployment: GatewayDeployment;
    provider: string;
    offeringId?: string;
    credentialIri?: string;
    refresh?: boolean;
    now?: Date;
    signal?: AbortSignal;
    auth?: AuthContext;
}
export interface CallerOwnedQuotaInput {
    webId: string;
    deployment: GatewayDeployment;
    provider: string;
    offeringId?: string;
    credentialId: string;
    credentialIri: string;
    authMode: 'apiKey' | 'deviceCodeOAuth';
    baseUrl?: string;
    proxyUrl?: string;
    secret: ProviderSecret;
    now?: Date;
    signal?: AbortSignal;
}
export interface ProviderQuotaServiceOptions {
    repository: QuotaSnapshotRepository;
    vault: CredentialVault;
    adapters: ProviderQuotaAdapter[];
    providerRegistry?: ProviderRegistry;
    credentialRepository?: PodCredentialRepository;
    credentials?: QuotaCredentialRecord[];
    now?: () => Date;
}
export declare class ProviderQuotaService {
    private readonly repository;
    private readonly vault;
    private readonly adapters;
    private readonly providerRegistry?;
    private readonly capabilityRegistry;
    private readonly credentialRepository?;
    private readonly credentials;
    private readonly now;
    private readonly inFlightRefreshes;
    constructor(options: ProviderQuotaServiceOptions);
    status(input: ProviderQuotaStatusInput): Promise<NormalizedQuotaSnapshot>;
    statusCallerOwned(input: CallerOwnedQuotaInput): Promise<NormalizedQuotaSnapshot>;
    private statusAfterImplicitCredentialResolution;
    private refreshAndCache;
    private fetchAndCache;
    private findAdapter;
    private resolveCredential;
}
export declare class InMemoryQuotaSnapshotRepository implements QuotaSnapshotRepository {
    readonly rows: Array<NormalizedQuotaSnapshot & {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
    }>;
    findFresh(input: {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
        credentialIri: string;
        now: Date;
    }): Promise<NormalizedQuotaSnapshot | undefined>;
    findLatest(input: {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
        credentialIri: string;
    }): Promise<NormalizedQuotaSnapshot | undefined>;
    upsert(input: {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
        snapshot: NormalizedQuotaSnapshot;
    }): Promise<NormalizedQuotaSnapshot>;
}
type QuotaSnapshotDb = {
    init?: (...resources: unknown[]) => Promise<void>;
    select(): {
        from(resource: typeof quotaSnapshotResource): {
            where(condition: unknown): {
                execute(): Promise<QuotaSnapshotRow[]>;
            };
        };
    };
    findById<TRow>(resource: typeof quotaSnapshotResource, id: string): Promise<TRow | null>;
    findByIri<TRow>(resource: typeof quotaSnapshotResource, iri: string): Promise<TRow | null>;
    updateById<TRow>(resource: typeof quotaSnapshotResource, id: string, patch: unknown): Promise<TRow | null>;
    updateByIri<TRow>(resource: typeof quotaSnapshotResource, iri: string, patch: unknown): Promise<TRow | null>;
    insert(resource: typeof quotaSnapshotResource): {
        values(value: unknown): {
            execute(): Promise<QuotaSnapshotRow[]>;
        };
    };
};
export interface PodQuotaSnapshotRepositoryOptions {
    internalPodAccess?: InternalPodAccessTokenProvider;
    podBaseUrlResolver?: PodBaseUrlResolver;
    dbFactory?: (input: {
        owner: string;
        auth?: AuthContext;
        fetch: typeof fetch;
        podUrl: string;
    }) => Promise<QuotaSnapshotDb>;
}
export declare class PodQuotaSnapshotRepository implements QuotaSnapshotRepository {
    private readonly dbFactory;
    private readonly internalPodAccess?;
    private readonly podBaseUrlResolver?;
    constructor(options?: PodQuotaSnapshotRepositoryOptions);
    findFresh(input: {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
        credentialIri: string;
        now: Date;
        auth?: AuthContext;
    }): Promise<NormalizedQuotaSnapshot | undefined>;
    findLatest(input: {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
        credentialIri: string;
        auth?: AuthContext;
    }): Promise<NormalizedQuotaSnapshot | undefined>;
    upsert(input: {
        webId: string;
        deployment: GatewayDeployment;
        provider: string;
        offeringId?: string;
        snapshot: NormalizedQuotaSnapshot;
        auth?: AuthContext;
    }): Promise<NormalizedQuotaSnapshot>;
    private dbForOwner;
    private resolveTrustedFetch;
    private wrapPodFetch;
}
export declare function unsupportedQuotaSnapshot(input: {
    credential: string;
    source: string;
    now: Date;
    ttlMs?: number;
    metadata?: Record<string, unknown>;
}): NormalizedQuotaSnapshot;
export declare function errorQuotaSnapshot(input: {
    credential: string;
    source: string;
    now: Date;
    status?: number;
    retryAfter?: string | null;
    ttlMs?: number;
    metadata?: Record<string, unknown>;
}): NormalizedQuotaSnapshot;
export declare function apiKeyFromSecret(secret: ProviderSecret): string | undefined;
export declare function fetchJsonWithBearer(input: {
    fetch: typeof fetch;
    transport?: ProviderHttpTransport;
    url: string;
    apiKey: string;
    proxy?: string;
    signal?: AbortSignal;
}): Promise<{
    ok: true;
    body: unknown;
} | {
    ok: false;
    status: number;
    retryAfter?: string | null;
}>;
export declare function numeric(value: unknown): number | undefined;
export declare function decimalAmount(value: unknown): {
    exact?: string;
    numeric?: number;
    displayApprox?: boolean;
};
export declare function normalizeProvider(provider: string): string;
export {};