@knn_labs/conduit-admin-client/dist/index.d.mts

TypeScript client library for Conduit Admin API

import { AxiosInstance } from 'axios';

interface Logger {
    debug(message: string, ...args: unknown[]): void;
    info(message: string, ...args: unknown[]): void;
    warn(message: string, ...args: unknown[]): void;
    error(message: string, ...args: unknown[]): void;
}
interface CacheProvider {
    get<T>(key: string): Promise<T | null>;
    set<T>(key: string, value: T, ttl?: number): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
}
interface AxiosError {
    code?: string;
    message: string;
    response?: {
        status: number;
        data: unknown;
        headers: Record<string, string>;
    };
    request?: unknown;
    config?: {
        url?: string;
        method?: string;
        _retry?: number;
    };
}
interface RetryConfig {
    maxRetries: number;
    retryDelay: number;
    retryCondition?: (error: AxiosError) => boolean;
}
interface ConduitConfig {
    masterKey: string;
    adminApiUrl: string;
    conduitApiUrl?: string;
    options?: {
        timeout?: number;
        retries?: number | RetryConfig;
        logger?: Logger;
        cache?: CacheProvider;
        headers?: Record<string, string>;
        validateStatus?: (status: number) => boolean;
    };
}
interface RequestConfig {
    method: string;
    url: string;
    data?: unknown;
    params?: Record<string, unknown>;
    headers?: Record<string, string>;
    timeout?: number;
}
interface ApiClientConfig {
    baseUrl: string;
    masterKey: string;
    timeout?: number;
    retries?: number | RetryConfig;
    logger?: Logger;
    cache?: CacheProvider;
    defaultHeaders?: Record<string, string>;
}

declare abstract class BaseApiClient {
    protected readonly axios: AxiosInstance;
    protected readonly logger?: Logger;
    protected readonly cache?: CacheProvider;
    protected readonly retryConfig: RetryConfig;
    constructor(config: ApiClientConfig);
    private normalizeRetryConfig;
    private setupInterceptors;
    protected request<T>(config: RequestConfig): Promise<T>;
    protected get<T>(url: string, params?: Record<string, unknown>, options?: RequestConfig): Promise<T>;
    protected post<T>(url: string, data?: unknown, options?: RequestConfig): Promise<T>;
    protected put<T>(url: string, data?: unknown, options?: RequestConfig): Promise<T>;
    protected delete<T>(url: string, options?: RequestConfig): Promise<T>;
    protected patch<T>(url: string, data?: unknown, options?: RequestConfig): Promise<T>;
    protected getCacheKey(prefix: string, ...parts: unknown[]): string;
    protected withCache<T>(key: string, fetcher: () => Promise<T>, ttl?: number): Promise<T>;
}

interface PaginatedResponse<T> {
    items: T[];
    totalCount: number;
    pageNumber: number;
    pageSize: number;
    totalPages: number;
}
interface ErrorResponse {
    error: string;
    message?: string;
    details?: Record<string, unknown>;
    statusCode?: number;
}
interface ApiResponse<T = unknown> {
    success: boolean;
    data?: T;
    error?: ErrorResponse;
}
type SortDirection = 'asc' | 'desc';
interface SortOptions {
    field: string;
    direction: SortDirection;
}
interface FilterOptions {
    search?: string;
    sortBy?: SortOptions;
    pageNumber?: number;
    pageSize?: number;
}
interface DateRange extends Record<string, string> {
    startDate: string;
    endDate: string;
}
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
interface RequestOptions {
    timeout?: number;
    retries?: number;
    headers?: Record<string, string>;
}

type BudgetDuration = 'Total' | 'Daily' | 'Weekly' | 'Monthly';
interface VirtualKeyDto {
    id: number;
    keyName: string;
    apiKey?: string;
    keyPrefix?: string;
    allowedModels: string;
    maxBudget: number;
    currentSpend: number;
    budgetDuration: BudgetDuration;
    budgetStartDate: string;
    isEnabled: boolean;
    expiresAt?: string;
    createdAt: string;
    updatedAt: string;
    metadata?: string;
    rateLimitRpm?: number;
    rateLimitRpd?: number;
    lastUsedAt?: string;
    requestCount?: number;
}
interface CreateVirtualKeyRequest {
    keyName: string;
    allowedModels?: string;
    maxBudget?: number;
    budgetDuration?: BudgetDuration;
    expiresAt?: string;
    metadata?: string;
    rateLimitRpm?: number;
    rateLimitRpd?: number;
}
interface CreateVirtualKeyResponse {
    virtualKey: string;
    keyInfo: VirtualKeyDto;
}
interface UpdateVirtualKeyRequest {
    keyName?: string;
    allowedModels?: string;
    maxBudget?: number;
    budgetDuration?: BudgetDuration;
    isEnabled?: boolean;
    expiresAt?: string;
    metadata?: string;
    rateLimitRpm?: number;
    rateLimitRpd?: number;
}
interface VirtualKeyValidationRequest {
    key: string;
}
interface VirtualKeyValidationResult {
    isValid: boolean;
    virtualKeyId?: number;
    keyName?: string;
    reason?: string;
    allowedModels?: string[];
    maxBudget?: number;
    currentSpend?: number;
    budgetRemaining?: number;
    expiresAt?: string;
    rateLimitRpm?: number;
    rateLimitRpd?: number;
}
interface UpdateSpendRequest {
    amount: number;
    description?: string;
}
interface CheckBudgetRequest {
    estimatedCost: number;
}
interface CheckBudgetResponse {
    hasAvailableBudget: boolean;
    availableBudget: number;
    estimatedCost: number;
    currentSpend: number;
    maxBudget: number;
}
interface VirtualKeyValidationInfo {
    keyId: number;
    keyName: string;
    isValid: boolean;
    validationErrors: string[];
    allowedModels: string[];
    budgetInfo: {
        maxBudget: number;
        currentSpend: number;
        remaining: number;
        duration: BudgetDuration;
    };
    rateLimits?: {
        rpm?: number;
        rpd?: number;
    };
    metadata?: Record<string, any>;
}
interface VirtualKeyMaintenanceRequest {
    cleanupExpiredKeys?: boolean;
    resetDailyBudgets?: boolean;
    resetWeeklyBudgets?: boolean;
    resetMonthlyBudgets?: boolean;
}
interface VirtualKeyMaintenanceResponse {
    expiredKeysDeleted?: number;
    dailyBudgetsReset?: number;
    weeklyBudgetsReset?: number;
    monthlyBudgetsReset?: number;
    errors?: string[];
}
interface VirtualKeyFilters extends FilterOptions {
    isEnabled?: boolean;
    hasExpired?: boolean;
    budgetDuration?: BudgetDuration;
    minBudget?: number;
    maxBudget?: number;
    allowedModel?: string;
    createdAfter?: string;
    createdBefore?: string;
    lastUsedAfter?: string;
    lastUsedBefore?: string;
}
interface VirtualKeyStatistics {
    totalKeys: number;
    activeKeys: number;
    expiredKeys: number;
    totalSpend: number;
    averageSpendPerKey: number;
    keysNearBudgetLimit: number;
    keysByDuration: Record<BudgetDuration, number>;
}

declare class VirtualKeyService extends BaseApiClient {
    create(request: CreateVirtualKeyRequest): Promise<CreateVirtualKeyResponse>;
    list(filters?: VirtualKeyFilters): Promise<VirtualKeyDto[]>;
    getById(id: number): Promise<VirtualKeyDto>;
    update(id: number, request: UpdateVirtualKeyRequest): Promise<void>;
    deleteById(id: number): Promise<void>;
    search(query: string): Promise<VirtualKeyDto[]>;
    resetSpend(id: number): Promise<void>;
    validate(key: string): Promise<VirtualKeyValidationResult>;
    updateSpend(id: number, request: UpdateSpendRequest): Promise<void>;
    checkBudget(id: number, estimatedCost: number): Promise<CheckBudgetResponse>;
    getValidationInfo(id: number): Promise<VirtualKeyValidationInfo>;
    performMaintenance(request?: VirtualKeyMaintenanceRequest): Promise<VirtualKeyMaintenanceResponse>;
    getStatistics(): Promise<VirtualKeyStatistics>;
    bulkCreate(_requests: CreateVirtualKeyRequest[]): Promise<CreateVirtualKeyResponse[]>;
    exportKeys(_format: 'csv' | 'json'): Promise<Blob>;
    private invalidateCache;
}

interface ProviderCredentialDto {
    id: number;
    providerName: string;
    apiKey?: string;
    apiEndpoint?: string;
    organizationId?: string;
    additionalConfig?: string;
    isEnabled: boolean;
    createdAt: string;
    updatedAt: string;
}
interface CreateProviderCredentialDto {
    providerName: string;
    apiKey?: string;
    apiEndpoint?: string;
    organizationId?: string;
    additionalConfig?: string;
    isEnabled?: boolean;
}
interface UpdateProviderCredentialDto {
    apiKey?: string;
    apiEndpoint?: string;
    organizationId?: string;
    additionalConfig?: string;
    isEnabled?: boolean;
}
interface ProviderConnectionTestRequest {
    providerName: string;
    apiKey?: string;
    apiEndpoint?: string;
    organizationId?: string;
    additionalConfig?: string;
}
interface ProviderConnectionTestResultDto {
    success: boolean;
    message: string;
    errorDetails?: string;
    providerName: string;
    modelsAvailable?: string[];
    responseTimeMs?: number;
    timestamp?: string;
}
interface ProviderDataDto {
    name: string;
    displayName: string;
    supportedModels: string[];
    requiresApiKey: boolean;
    requiresEndpoint: boolean;
    requiresOrganizationId: boolean;
    configSchema?: Record<string, any>;
}
interface ProviderHealthConfigurationDto {
    providerName: string;
    isEnabled: boolean;
    checkIntervalSeconds: number;
    timeoutSeconds: number;
    unhealthyThreshold: number;
    healthyThreshold: number;
    testModel?: string;
    lastCheckTime?: string;
    isHealthy?: boolean;
    consecutiveFailures?: number;
    consecutiveSuccesses?: number;
}
interface UpdateProviderHealthConfigurationDto {
    isEnabled?: boolean;
    checkIntervalSeconds?: number;
    timeoutSeconds?: number;
    unhealthyThreshold?: number;
    healthyThreshold?: number;
    testModel?: string;
}
interface ProviderHealthRecordDto {
    id: number;
    providerName: string;
    checkTime: string;
    isHealthy: boolean;
    responseTimeMs?: number;
    errorMessage?: string;
    statusCode?: number;
    modelsChecked?: string[];
}
interface ProviderHealthStatusDto {
    providerName: string;
    isHealthy: boolean;
    lastCheckTime?: string;
    lastSuccessTime?: string;
    lastFailureTime?: string;
    consecutiveFailures: number;
    consecutiveSuccesses: number;
    averageResponseTimeMs?: number;
    uptime?: number;
    errorRate?: number;
}
interface ProviderHealthSummaryDto {
    totalProviders: number;
    healthyProviders: number;
    unhealthyProviders: number;
    unconfiguredProviders: number;
    providers: ProviderHealthStatusDto[];
}
interface ProviderFilters extends FilterOptions {
    isEnabled?: boolean;
    providerName?: string;
    hasApiKey?: boolean;
    isHealthy?: boolean;
}
interface ProviderHealthFilters extends FilterOptions {
    providerName?: string;
    isHealthy?: boolean;
    startDate?: string;
    endDate?: string;
    minResponseTime?: number;
    maxResponseTime?: number;
}
interface ProviderUsageStatistics {
    providerName: string;
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageResponseTime: number;
    totalCost: number;
    modelsUsed: Record<string, number>;
    errorTypes: Record<string, number>;
    timeRange: {
        start: string;
        end: string;
    };
}

declare class ProviderService extends BaseApiClient {
    create(request: CreateProviderCredentialDto): Promise<ProviderCredentialDto>;
    list(filters?: ProviderFilters): Promise<ProviderCredentialDto[]>;
    getById(id: number): Promise<ProviderCredentialDto>;
    getByName(providerName: string): Promise<ProviderCredentialDto>;
    getProviderNames(): Promise<string[]>;
    update(id: number, request: UpdateProviderCredentialDto): Promise<void>;
    deleteById(id: number): Promise<void>;
    testConnectionById(id: number): Promise<ProviderConnectionTestResultDto>;
    testConnection(request: ProviderConnectionTestRequest): Promise<ProviderConnectionTestResultDto>;
    getHealthConfigurations(): Promise<ProviderHealthConfigurationDto[]>;
    getHealthConfiguration(providerName: string): Promise<ProviderHealthConfigurationDto>;
    updateHealthConfiguration(providerName: string, request: UpdateProviderHealthConfigurationDto): Promise<void>;
    getHealthStatus(): Promise<ProviderHealthSummaryDto>;
    getProviderHealthStatus(providerName: string): Promise<ProviderHealthStatusDto>;
    getHealthHistory(filters?: ProviderHealthFilters): Promise<PaginatedResponse<ProviderHealthRecordDto>>;
    checkHealth(providerName: string): Promise<ProviderConnectionTestResultDto>;
    getUsageStatistics(_providerName: string, _startDate?: string, _endDate?: string): Promise<ProviderUsageStatistics>;
    bulkTest(_providerNames: string[]): Promise<ProviderConnectionTestResultDto[]>;
    getAvailableProviders(): Promise<ProviderDataDto[]>;
    private invalidateCache;
    private invalidateCachePattern;
}

interface ModelProviderMappingDto {
    id: number;
    modelId: string;
    providerId: string;
    providerModelId: string;
    isEnabled: boolean;
    priority: number;
    createdAt: string;
    updatedAt: string;
    metadata?: string;
}
interface CreateModelProviderMappingDto {
    modelId: string;
    providerId: string;
    providerModelId: string;
    isEnabled?: boolean;
    priority?: number;
    metadata?: string;
}
interface UpdateModelProviderMappingDto {
    providerId?: string;
    providerModelId?: string;
    isEnabled?: boolean;
    priority?: number;
    metadata?: string;
}
interface ModelMappingFilters extends FilterOptions {
    modelId?: string;
    providerId?: string;
    isEnabled?: boolean;
    minPriority?: number;
    maxPriority?: number;
}
interface ModelProviderInfo {
    providerId: string;
    providerName: string;
    providerModelId: string;
    isAvailable: boolean;
    isEnabled: boolean;
    priority: number;
    estimatedCost?: {
        inputTokenCost: number;
        outputTokenCost: number;
        currency: string;
    };
}
interface ModelRoutingInfo {
    modelId: string;
    primaryProvider?: ModelProviderInfo;
    fallbackProviders: ModelProviderInfo[];
    loadBalancingEnabled: boolean;
    routingStrategy: 'priority' | 'round-robin' | 'least-cost' | 'fastest';
}
interface BulkMappingRequest {
    mappings: CreateModelProviderMappingDto[];
    replaceExisting?: boolean;
}
interface BulkMappingResponse {
    created: ModelProviderMappingDto[];
    updated: ModelProviderMappingDto[];
    failed: {
        index: number;
        error: string;
        mapping: CreateModelProviderMappingDto;
    }[];
}
interface ModelMappingSuggestion {
    modelId: string;
    suggestedProviders: {
        providerId: string;
        providerName: string;
        providerModelId: string;
        confidence: number;
        reasoning: string;
        estimatedPerformance?: {
            latency: number;
            reliability: number;
            costEfficiency: number;
        };
    }[];
}

declare class ModelMappingService extends BaseApiClient {
    create(request: CreateModelProviderMappingDto): Promise<ModelProviderMappingDto>;
    list(filters?: ModelMappingFilters): Promise<ModelProviderMappingDto[]>;
    getById(id: number): Promise<ModelProviderMappingDto>;
    getByModel(modelId: string): Promise<ModelProviderMappingDto[]>;
    update(id: number, request: UpdateModelProviderMappingDto): Promise<void>;
    deleteById(id: number): Promise<void>;
    getAvailableProviders(): Promise<string[]>;
    updatePriority(id: number, priority: number): Promise<void>;
    enableMapping(id: number): Promise<void>;
    disableMapping(id: number): Promise<void>;
    reorderMappings(_modelId: string, mappingIds: number[]): Promise<void>;
    getRoutingInfo(_modelId: string): Promise<ModelRoutingInfo>;
    bulkCreate(_request: BulkMappingRequest): Promise<BulkMappingResponse>;
    importMappings(_file: File | Blob, _format: 'csv' | 'json'): Promise<BulkMappingResponse>;
    exportMappings(_format: 'csv' | 'json'): Promise<Blob>;
    suggestOptimalMapping(_modelId: string): Promise<ModelMappingSuggestion>;
    private invalidateCache;
}

interface GlobalSettingDto {
    key: string;
    value: string;
    description?: string;
    dataType: 'string' | 'number' | 'boolean' | 'json';
    category?: string;
    isSecret?: boolean;
    createdAt: string;
    updatedAt: string;
}
interface CreateGlobalSettingDto {
    key: string;
    value: string;
    description?: string;
    dataType?: 'string' | 'number' | 'boolean' | 'json';
    category?: string;
    isSecret?: boolean;
}
interface UpdateGlobalSettingDto {
    value: string;
    description?: string;
    category?: string;
}
interface SettingCategory {
    name: string;
    description: string;
    settings: GlobalSettingDto[];
}
interface AudioConfigurationDto {
    provider: string;
    isEnabled: boolean;
    apiKey?: string;
    apiEndpoint?: string;
    defaultVoice?: string;
    defaultModel?: string;
    maxDuration?: number;
    allowedVoices?: string[];
    customSettings?: Record<string, any>;
    createdAt: string;
    updatedAt: string;
}
interface CreateAudioConfigurationDto {
    provider: string;
    isEnabled?: boolean;
    apiKey?: string;
    apiEndpoint?: string;
    defaultVoice?: string;
    defaultModel?: string;
    maxDuration?: number;
    allowedVoices?: string[];
    customSettings?: Record<string, any>;
}
interface UpdateAudioConfigurationDto {
    isEnabled?: boolean;
    apiKey?: string;
    apiEndpoint?: string;
    defaultVoice?: string;
    defaultModel?: string;
    maxDuration?: number;
    allowedVoices?: string[];
    customSettings?: Record<string, any>;
}
interface RouterConfigurationDto {
    routingStrategy: 'priority' | 'round-robin' | 'least-cost' | 'fastest' | 'random';
    fallbackEnabled: boolean;
    maxRetries: number;
    retryDelay: number;
    loadBalancingEnabled: boolean;
    healthCheckEnabled: boolean;
    healthCheckInterval: number;
    circuitBreakerEnabled: boolean;
    circuitBreakerThreshold: number;
    circuitBreakerDuration: number;
    customRules?: RouterRule[];
    createdAt: string;
    updatedAt: string;
}
interface RouterRule {
    id?: number;
    name: string;
    condition: RouterCondition;
    action: RouterAction;
    priority: number;
    isEnabled: boolean;
}
interface RouterCondition {
    type: 'model' | 'key' | 'metadata' | 'time' | 'cost';
    operator: 'equals' | 'contains' | 'greater_than' | 'less_than' | 'between';
    value: any;
}
interface RouterAction {
    type: 'route_to_provider' | 'block' | 'rate_limit' | 'add_metadata';
    value: any;
}
interface UpdateRouterConfigurationDto {
    routingStrategy?: 'priority' | 'round-robin' | 'least-cost' | 'fastest' | 'random';
    fallbackEnabled?: boolean;
    maxRetries?: number;
    retryDelay?: number;
    loadBalancingEnabled?: boolean;
    healthCheckEnabled?: boolean;
    healthCheckInterval?: number;
    circuitBreakerEnabled?: boolean;
    circuitBreakerThreshold?: number;
    circuitBreakerDuration?: number;
    customRules?: RouterRule[];
}
interface SystemConfiguration {
    general: GlobalSettingDto[];
    audio: AudioConfigurationDto[];
    router: RouterConfigurationDto;
    categories: SettingCategory[];
}
interface SettingFilters extends FilterOptions {
    category?: string;
    dataType?: string;
    isSecret?: boolean;
    searchKey?: string;
}

declare class SettingsService extends BaseApiClient {
    getGlobalSettings(filters?: SettingFilters): Promise<GlobalSettingDto[]>;
    getGlobalSetting(key: string): Promise<GlobalSettingDto>;
    createGlobalSetting(request: CreateGlobalSettingDto): Promise<GlobalSettingDto>;
    updateGlobalSetting(key: string, request: UpdateGlobalSettingDto): Promise<void>;
    deleteGlobalSetting(key: string): Promise<void>;
    getAudioConfigurations(): Promise<AudioConfigurationDto[]>;
    getAudioConfiguration(provider: string): Promise<AudioConfigurationDto>;
    createAudioConfiguration(request: CreateAudioConfigurationDto): Promise<AudioConfigurationDto>;
    updateAudioConfiguration(provider: string, request: UpdateAudioConfigurationDto): Promise<void>;
    deleteAudioConfiguration(provider: string): Promise<void>;
    getRouterConfiguration(): Promise<RouterConfigurationDto>;
    updateRouterConfiguration(request: UpdateRouterConfigurationDto): Promise<void>;
    getSetting(key: string): Promise<string>;
    setSetting(key: string, value: string, options?: {
        description?: string;
        dataType?: 'string' | 'number' | 'boolean' | 'json';
        category?: string;
        isSecret?: boolean;
    }): Promise<void>;
    getSettingsByCategory(category: string): Promise<GlobalSettingDto[]>;
    getSystemConfiguration(): Promise<SystemConfiguration>;
    exportSettings(_format: 'json' | 'env'): Promise<Blob>;
    importSettings(_file: File | Blob, _format: 'json' | 'env'): Promise<{
        imported: number;
        skipped: number;
        errors: string[];
    }>;
    validateConfiguration(): Promise<{
        isValid: boolean;
        errors: string[];
        warnings: string[];
    }>;
    private invalidateCache;
}

type FilterType = 'Allow' | 'Deny';
type FilterMode = 'permissive' | 'restrictive';
interface IpFilterDto {
    id: number;
    name: string;
    cidrRange: string;
    filterType: FilterType;
    isEnabled: boolean;
    description?: string;
    createdAt: string;
    updatedAt: string;
    lastMatchedAt?: string;
    matchCount?: number;
}
interface CreateIpFilterDto {
    name: string;
    cidrRange: string;
    filterType: FilterType;
    isEnabled?: boolean;
    description?: string;
}
interface UpdateIpFilterDto {
    name?: string;
    cidrRange?: string;
    filterType?: FilterType;
    isEnabled?: boolean;
    description?: string;
}
interface IpFilterSettingsDto {
    isEnabled: boolean;
    defaultAllow: boolean;
    bypassForAdminUi: boolean;
    excludedEndpoints: string[];
    filterMode: FilterMode;
    whitelistFilters: IpFilterDto[];
    blacklistFilters: IpFilterDto[];
    maxFiltersPerType?: number;
    ipv6Enabled?: boolean;
}
interface UpdateIpFilterSettingsDto {
    isEnabled?: boolean;
    defaultAllow?: boolean;
    bypassForAdminUi?: boolean;
    excludedEndpoints?: string[];
    filterMode?: FilterMode;
    ipv6Enabled?: boolean;
}
interface IpCheckRequest {
    ipAddress: string;
    endpoint?: string;
}
interface IpCheckResult {
    isAllowed: boolean;
    reason?: string;
    matchedFilter?: string;
    matchedFilterId?: number;
    filterType?: FilterType;
    isDefaultAction?: boolean;
}
interface IpFilterFilters extends FilterOptions {
    filterType?: FilterType;
    isEnabled?: boolean;
    nameContains?: string;
    cidrContains?: string;
    lastMatchedAfter?: string;
    lastMatchedBefore?: string;
    minMatchCount?: number;
}
interface IpFilterStatistics {
    totalFilters: number;
    enabledFilters: number;
    allowFilters: number;
    denyFilters: number;
    totalMatches: number;
    recentMatches: {
        timestamp: string;
        ipAddress: string;
        filterName: string;
        action: 'allowed' | 'denied';
    }[];
    topMatchedFilters: {
        filterId: number;
        filterName: string;
        matchCount: number;
    }[];
}
interface BulkIpFilterRequest {
    filters: CreateIpFilterDto[];
    replaceExisting?: boolean;
    filterType?: FilterType;
}
interface BulkIpFilterResponse {
    created: IpFilterDto[];
    updated: IpFilterDto[];
    failed: {
        index: number;
        error: string;
        filter: CreateIpFilterDto;
    }[];
}
interface IpFilterValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    suggestedCidr?: string;
    overlappingFilters?: {
        id: number;
        name: string;
        cidrRange: string;
    }[];
}

declare class IpFilterService extends BaseApiClient {
    create(request: CreateIpFilterDto): Promise<IpFilterDto>;
    list(filters?: IpFilterFilters): Promise<IpFilterDto[]>;
    getById(id: number): Promise<IpFilterDto>;
    getEnabled(): Promise<IpFilterDto[]>;
    update(id: number, request: UpdateIpFilterDto): Promise<void>;
    deleteById(id: number): Promise<void>;
    getSettings(): Promise<IpFilterSettingsDto>;
    updateSettings(request: UpdateIpFilterSettingsDto): Promise<void>;
    checkIp(ipAddress: string, endpoint?: string): Promise<IpCheckResult>;
    search(query: string): Promise<IpFilterDto[]>;
    enableFilter(id: number): Promise<void>;
    disableFilter(id: number): Promise<void>;
    createAllowFilter(name: string, cidrRange: string, description?: string): Promise<IpFilterDto>;
    createDenyFilter(name: string, cidrRange: string, description?: string): Promise<IpFilterDto>;
    getFiltersByType(filterType: FilterType): Promise<IpFilterDto[]>;
    getStatistics(): Promise<IpFilterStatistics>;
    bulkCreate(_request: BulkIpFilterRequest): Promise<BulkIpFilterResponse>;
    importFilters(_file: File | Blob, _format: 'csv' | 'json'): Promise<BulkIpFilterResponse>;
    exportFilters(_format: 'csv' | 'json', _filterType?: FilterType): Promise<Blob>;
    validateCidr(_cidrRange: string): Promise<IpFilterValidationResult>;
    testRules(_ipAddress: string, _proposedRules?: CreateIpFilterDto[]): Promise<{
        currentResult: IpCheckResult;
        proposedResult?: IpCheckResult;
        changes?: string[];
    }>;
    private invalidateCache;
}

interface ModelCostDto {
    id: number;
    modelId: string;
    inputTokenCost: number;
    outputTokenCost: number;
    currency: string;
    effectiveDate: string;
    expiryDate?: string;
    providerId?: string;
    description?: string;
    isActive: boolean;
    createdAt: string;
    updatedAt: string;
}
interface CreateModelCostDto {
    modelId: string;
    inputTokenCost: number;
    outputTokenCost: number;
    currency?: string;
    effectiveDate?: string;
    expiryDate?: string;
    providerId?: string;
    description?: string;
    isActive?: boolean;
}
interface UpdateModelCostDto {
    inputTokenCost?: number;
    outputTokenCost?: number;
    currency?: string;
    effectiveDate?: string;
    expiryDate?: string;
    providerId?: string;
    description?: string;
    isActive?: boolean;
}
interface ModelCostFilters extends FilterOptions {
    modelId?: string;
    providerId?: string;
    currency?: string;
    isActive?: boolean;
    effectiveAfter?: string;
    effectiveBefore?: string;
    minInputCost?: number;
    maxInputCost?: number;
    minOutputCost?: number;
    maxOutputCost?: number;
}
interface ModelCostCalculation {
    modelId: string;
    inputTokens: number;
    outputTokens: number;
    inputCost: number;
    outputCost: number;
    totalCost: number;
    currency: string;
    costPerThousandInputTokens: number;
    costPerThousandOutputTokens: number;
}
interface BulkModelCostUpdate {
    modelIds: string[];
    adjustment: {
        type: 'percentage' | 'fixed';
        value: number;
        applyTo: 'input' | 'output' | 'both';
    };
    effectiveDate?: string;
    reason?: string;
}
interface ModelCostHistory {
    modelId: string;
    history: {
        id: number;
        inputTokenCost: number;
        outputTokenCost: number;
        effectiveDate: string;
        expiryDate?: string;
        changeReason?: string;
    }[];
}
interface CostEstimate {
    scenarios: {
        name: string;
        inputTokens: number;
        outputTokens: number;
    }[];
    models: string[];
    results: {
        scenario: string;
        costs: {
            modelId: string;
            totalCost: number;
            inputCost: number;
            outputCost: number;
            currency: string;
        }[];
    }[];
    recommendations?: {
        mostCostEffective: string;
        bestValueForMoney: string;
        notes: string[];
    };
}
interface ModelCostComparison {
    baseModel: string;
    comparisonModels: string[];
    inputTokens: number;
    outputTokens: number;
    results: {
        modelId: string;
        totalCost: number;
        costDifference: number;
        percentageDifference: number;
        currency: string;
    }[];
}

declare class ModelCostService extends BaseApiClient {
    create(request: CreateModelCostDto): Promise<ModelCostDto>;
    list(filters?: ModelCostFilters): Promise<ModelCostDto[]>;
    getById(id: number): Promise<ModelCostDto>;
    getByModel(modelId: string): Promise<ModelCostDto[]>;
    update(id: number, request: UpdateModelCostDto): Promise<void>;
    deleteById(id: number): Promise<void>;
    calculateCost(modelId: string, inputTokens: number, outputTokens: number): Promise<ModelCostCalculation>;
    getCurrentCost(modelId: string): Promise<ModelCostDto | null>;
    updateCosts(models: string[], inputCost: number, outputCost: number): Promise<void>;
    bulkUpdate(_request: BulkModelCostUpdate): Promise<{
        updated: ModelCostDto[];
        failed: {
            modelId: string;
            error: string;
        }[];
    }>;
    getHistory(_modelId: string): Promise<ModelCostHistory>;
    estimateCosts(_scenarios: {
        name: string;
        inputTokens: number;
        outputTokens: number;
    }[], _models: string[]): Promise<CostEstimate>;
    compareCosts(_baseModel: string, _comparisonModels: string[], _inputTokens: number, _outputTokens: number): Promise<ModelCostComparison>;
    importCosts(_file: File | Blob, _format: 'csv' | 'json'): Promise<{
        imported: number;
        updated: number;
        failed: {
            row: number;
            error: string;
        }[];
    }>;
    exportCosts(_format: 'csv' | 'json', _activeOnly?: boolean): Promise<Blob>;
    private invalidateCache;
}

interface CostSummaryDto {
    totalCost: number;
    totalInputTokens: number;
    totalOutputTokens: number;
    currency: string;
    period: DateRange;
    costByModel: {
        modelId: string;
        cost: number;
        inputTokens: number;
        outputTokens: number;
        requestCount: number;
    }[];
    costByKey: {
        keyId: number;
        keyName: string;
        cost: number;
        requestCount: number;
    }[];
    costByProvider: {
        providerId: string;
        providerName: string;
        cost: number;
        requestCount: number;
    }[];
}
interface CostByPeriodDto {
    periods: {
        period: string;
        startDate: string;
        endDate: string;
        totalCost: number;
        inputTokens: number;
        outputTokens: number;
        requestCount: number;
    }[];
    totalCost: number;
    averageCostPerPeriod: number;
    trend: 'increasing' | 'decreasing' | 'stable';
    trendPercentage: number;
}
interface RequestLogDto {
    id: string;
    timestamp: string;
    virtualKeyId?: number;
    virtualKeyName?: string;
    model: string;
    provider: string;
    inputTokens: number;
    outputTokens: number;
    cost: number;
    currency: string;
    duration: number;
    status: 'success' | 'error' | 'timeout';
    errorMessage?: string;
    ipAddress?: string;
    userAgent?: string;
    requestHeaders?: Record<string, string>;
    responseHeaders?: Record<string, string>;
    metadata?: Record<string, any>;
}
interface RequestLogFilters extends FilterOptions {
    startDate?: string;
    endDate?: string;
    virtualKeyId?: number;
    model?: string;
    provider?: string;
    status?: 'success' | 'error' | 'timeout';
    minCost?: number;
    maxCost?: number;
    minDuration?: number;
    maxDuration?: number;
    ipAddress?: string;
}
interface UsageMetricsDto {
    period: DateRange;
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageLatency: number;
    p95Latency: number;
    p99Latency: number;
    requestsPerMinute: number;
    peakRequestsPerMinute: number;
    uniqueKeys: number;
    uniqueModels: number;
    errorRate: number;
}
interface ModelUsageDto {
    modelId: string;
    totalRequests: number;
    totalTokens: number;
    totalCost: number;
    averageTokensPerRequest: number;
    averageCostPerRequest: number;
    successRate: number;
    averageLatency: number;
    popularKeys: {
        keyId: number;
        keyName: string;
        requestCount: number;
    }[];
}
interface KeyUsageDto {
    keyId: number;
    keyName: string;
    totalRequests: number;
    totalCost: number;
    budgetUsed: number;
    budgetRemaining: number;
    averageCostPerRequest: number;
    requestsPerDay: number;
    popularModels: {
        modelId: string;
        requestCount: number;
        totalCost: number;
    }[];
    lastUsed: string;
}
interface AnalyticsFilters {
    startDate: string;
    endDate: string;
    virtualKeyIds?: number[];
    models?: string[];
    providers?: string[];
    groupBy?: 'hour' | 'day' | 'week' | 'month';
    includeMetadata?: boolean;
}
interface CostForecastDto {
    forecastPeriod: DateRange;
    predictedCost: number;
    confidence: number;
    basedOnPeriod: DateRange;
    factors: {
        name: string;
        impact: number;
        description: string;
    }[];
    recommendations: string[];
}
interface AnomalyDto {
    id: string;
    detectedAt: string;
    type: 'cost_spike' | 'usage_spike' | 'error_rate' | 'latency';
    severity: 'low' | 'medium' | 'high';
    description: string;
    affectedResources: {
        type: 'key' | 'model' | 'provider';
        id: string;
        name: string;
    }[];
    metrics: Record<string, any>;
    resolved: boolean;
}

declare class AnalyticsService extends BaseApiClient {
    getCostSummary(dateRange: DateRange): Promise<CostSummaryDto>;
    getCostByPeriod(dateRange: DateRange, groupBy?: 'hour' | 'day' | 'week' | 'month'): Promise<CostByPeriodDto>;
    getCostByModel(dateRange: DateRange): Promise<{
        models: ModelUsageDto[];
        totalCost: number;
    }>;
    getCostByKey(dateRange: DateRange): Promise<{
        keys: KeyUsageDto[];
        totalCost: number;
    }>;
    getRequestLogs(filters?: RequestLogFilters): Promise<PaginatedResponse<RequestLogDto>>;
    getRequestLog(id: string): Promise<RequestLogDto>;
    searchLogs(query: string, filters?: RequestLogFilters): Promise<RequestLogDto[]>;
    getUsageMetrics(dateRange: DateRange): Promise<UsageMetricsDto>;
    getModelUsage(modelId: string, dateRange: DateRange): Promise<ModelUsageDto>;
    getKeyUsage(keyId: number, dateRange: DateRange): Promise<KeyUsageDto>;
    getTodayCosts(): Promise<CostSummaryDto>;
    getMonthCosts(): Promise<CostSummaryDto>;
    getDetailedCostBreakdown(_filters: AnalyticsFilters): Promise<any>;
    predictFutureCosts(_basePeriod: DateRange, _forecastDays: number): Promise<CostForecastDto>;
    exportAnalytics(_filters: AnalyticsFilters, _format: 'csv' | 'excel' | 'json'): Promise<Blob>;
    detectAnomalies(_dateRange: DateRange): Promise<AnomalyDto[]>;
    streamRequestLogs(_filters?: RequestLogFilters, _onMessage?: (log: RequestLogDto) => void, _onError?: (error: Error) => void): Promise<() => void>;
    generateReport(_type: 'cost' | 'usage' | 'performance', _dateRange: DateRange, _options?: Record<string, any>): Promise<Blob>;
}

interface SystemInfoDto {
    version: string;
    buildDate: string;
    environment: string;
    uptime: number;
    systemTime: string;
    features: {
        ipFiltering: boolean;
        providerHealth: boolean;
        costTracking: boolean;
        audioSupport: boolean;
    };
    runtime: {
        dotnetVersion: string;
        os: string;
        architecture: string;
        memoryUsage: number;
        cpuUsage?: number;
    };
    database: {
        provider: string;
        connectionString?: string;
        isConnected: boolean;
        pendingMigrations?: string[];
    };
}
interface HealthStatusDto {
    status: 'healthy' | 'degraded' | 'unhealthy';
    timestamp: string;
    checks: {
        [key: string]: {
            status: 'healthy' | 'degraded' | 'unhealthy';
            description?: string;
            duration?: number;
            error?: string;
        };
    };
    totalDuration: number;
}
interface BackupDto {
    id: string;
    filename: string;
    createdAt: string;
    size: number;
    type: 'manual' | 'scheduled';
    status: 'completed' | 'in_progress' | 'failed';
    error?: string;
    downloadUrl?: string;
    expiresAt?: string;
}
interface CreateBackupRequest {
    description?: string;
    includeKeys?: boolean;
    includeProviders?: boolean;
    includeSettings?: boolean;
    includeLogs?: boolean;
    encryptionPassword?: string;
}
interface RestoreBackupRequest {
    backupId: string;
    decryptionPassword?: string;
    overwriteExisting?: boolean;
    selectedItems?: {
        keys?: boolean;
        providers?: boolean;
        settings?: boolean;
        logs?: boolean;
    };
}
interface BackupRestoreResult {
    success: boolean;
    restoredItems: {
        keys?: number;
        providers?: number;
        settings?: number;
        logs?: number;
    };
    errors?: string[];
    warnings?: string[];
}
interface NotificationDto {
    id: number;
    type: 'info' | 'warning' | 'error' | 'success';
    title: string;
    message: string;
    timestamp: string;
    isRead: boolean;
    metadata?: Record<string, any>;
    actionUrl?: string;
    expiresAt?: string;
}
interface CreateNotificationDto {
    type: 'info' | 'warning' | 'error' | 'success';
    title: string;
    message: string;
    metadata?: Record<string, any>;
    actionUrl?: string;
    expiresAt?: string;
}
interface MaintenanceTaskDto {
    name: string;
    description: string;
    lastRun?: string;
    nextRun?: string;
    status: 'idle' | 'running' | 'failed';
    canRunManually: boolean;
    schedule?: string;
}
interface RunMaintenanceTaskRequest {
    taskName: string;
    parameters?: Record<string, any>;
}
interface MaintenanceTaskResult {
    taskName: string;
    startTime: string;
    endTime: string;
    success: boolean;
    itemsProcessed?: number;
    errors?: string[];
    logs?: string[];
}
interface AuditLogDto {
    id: string;
    timestamp: string;
    action: string;
    category: 'auth' | 'config' | 'data' | 'system';
    userId?: string;
    ipAddress?: string;
    userAgent?: string;
    resourceType?: string;
    resourceId?: string;
    oldValue?: any;
    newValue?: any;
    result: 'success' | 'failure';
    errorMessage?: string;
}
interface AuditLogFilters extends FilterOptions {
    startDate?: string;
    endDate?: string;
    action?: string;
    category?: string;
    userId?: string;
    ipAddress?: string;
    resourceType?: string;
    result?: 'success' | 'failure';
}
interface SystemMetricsDto {
    timestamp: string;
    cpu: {
        usage: number;
        cores: number;
    };
    memory: {
        used: number;
        total: number;
        percentage: number;
    };
    disk: {
        used: number;
        total: number;
        percentage: number;
    };
    network: {
        bytesIn: number;
        bytesOut: number;
        requestsPerSecond: number;
    };
    database: {
        connections: number;
        maxConnections: number;
        queryTime: number;
    };
}

declare class SystemService extends BaseApiClient {
    getSystemInfo(): Promise<SystemInfoDto>;
    getHealth(): Promise<HealthStatusDto>;
    getSystemMetrics(): Promise<SystemMetricsDto>;
    listBackups(): Promise<BackupDto[]>;
    createBackup(request?: CreateBackupRequest): Promise<BackupDto>;
    downloadBackup(backupId: string): Promise<Blob>;
    deleteBackup(backupId: string): Promise<void>;
    restoreBackup(request: RestoreBackupRequest): Promise<BackupRestoreResult>;
    getNotifications(unreadOnly?: boolean): Promise<NotificationDto[]>;
    getNotification(id: number): Promise<NotificationDto>;
    createNotification(request: CreateNotificationDto): Promise<NotificationDto>;
    markNotificationRead(id: number): Promise<void>;
    deleteNotification(id: number): Promise<void>;
    clearNotifications(): Promise<void>;
    getMaintenanceTasks(): Promise<MaintenanceTaskDto[]>;
    runMaintenanceTask(request: RunMaintenanceTaskRequest): Promise<MaintenanceTaskResult>;
    getAuditLogs(_filters?: AuditLogFilters): Promise<PaginatedResponse<AuditLogDto>>;
    scheduledBackup(_schedule: string, _config: CreateBackupRequest): Promise<{
        id: string;
        schedule: string;
        nextRun: string;
        config: CreateBackupRequest;
    }>;
    getScheduledBackups(): Promise<Array<{
        id: string;
        schedule: string;
        nextRun: string;
        lastRun?: string;
        config: CreateBackupRequest;
    }>>;
    exportAuditLogs(_filters: AuditLogFilters, _format: 'csv' | 'json'): Promise<Blob>;
    getDiagnostics(): Promise<{
        timestamp: string;
        checks: Record<string, any>;
        recommendations: string[];
        issues: Array<{
            severity: 'low' | 'medium' | 'high';
            component: string;
            message: string;
            solution?: string;
        }>;
    }>;
    streamSystemMetrics(_onMessage?: (metrics: SystemMetricsDto) => void, _onError?: (error: Error) => void): Promise<() => void>;
    private invalidateCache;
}

declare class ConduitAdminClient {
    readonly virtualKeys: VirtualKeyService;
    readonly providers: ProviderService;
    readonly modelMappings: ModelMappingService;
    readonly settings: SettingsService;
    readonly ipFilters: IpFilterService;
    readonly modelCosts: ModelCostService;
    readonly analytics: AnalyticsService;
    readonly system: SystemService;
    private readonly config;
    constructor(config: ConduitConfig);
    static fromEnvironment(env?: {
        CONDUIT_MASTER_KEY?: string;
        CONDUIT_ADMIN_API_URL?: string;
        CONDUIT_ADMIN_API_BASE_URL?: string;
        CONDUIT_API_URL?: string;
    }): ConduitAdminClient;
    getConfig(): Readonly<ConduitConfig>;
    private normalizeUrl;
}

declare class ConduitError extends Error {
    statusCode?: number;
    details?: unknown;
    endpoint?: string;
    method?: string;
    constructor(message: string, statusCode?: number, details?: unknown, endpoint?: string, method?: string);
    toJSON(): {
        name: string;
        message: string;
        statusCode: number | undefined;
        details: unknown;
        endpoint: string | undefined;
        method: string | undefined;
    };
}
declare class AuthenticationError extends ConduitError {
    constructor(message?: string, details?: unknown, endpoint?: string, method?: string);
}
declare class AuthorizationError extends ConduitError {
    constructor(message?: string, details?: unknown, endpoint?: string, method?: string);
}
declare class ValidationError extends ConduitError {
    constructor(message?: string, details?: unknown, endpoint?: string, method?: string);
}
declare class NotFoundError extends ConduitError {
    constructor(message?: string, details?: unknown, endpoint?: string, method?: string);
}
declare class ConflictError extends ConduitError {
    constructor(message?: string, details?: unknown, endpoint?: string, method?: string);
}
declare class RateLimitError extends ConduitError {
    retryAfter?: number;
    constructor(message?: string, retryAfter?: number, details?: unknown, endpoint?: string, method?: string);
}
declare class ServerError extends ConduitError {
    constructor(message?: string, details?: unknown, endpoint?: string, method?: string);
}
declare class NetworkError extends ConduitError {
    constructor(message?: string, details?: unknown);
}
declare class TimeoutError extends ConduitError {
    constructor(message?: string, details?: unknown);
}
declare class NotImplementedError extends ConduitError {
    constructor(message: string, details?: unknown);
}
declare function isConduitError(error: unknown): error is ConduitError;
declare function handleApiError(error: unknown, endpoint?: string, method?: string): never;

declare const API_VERSION = "v1";
declare const API_PREFIX = "/api";
declare const ENDPOINTS: {
    readonly VIRTUAL_KEYS: {
        readonly BASE: "/virtualkeys";
        readonly BY_ID: (id: number) => string;
        readonly RESET_SPEND: (id: number) => string;
        readonly VALIDATE: "/virtualkeys/validate";
        readonly SPEND: (id: number) => string;
        readonly CHECK_BUDGET: (id: number) => string;
        readonly VALIDATION_INFO: (id: number) => string;
        readonly MAINTENANCE: "/virtualkeys/maintenance";
    };
    readonly PROVIDERS: {
        readonly BASE: "/providercredentials";
        readonly BY_ID: (id: number) => string;
        readonly BY_NAME: (name: string) => string;
        readonly NAMES: "/providercredentials/names";
        readonly TEST_BY_ID: (id: number) => string;
        readonly TEST: "/providercredentials/test";
    };
    readonly MODEL_MAPPINGS: {
        readonly BASE: "/modelprovidermapping";
        readonly BY_ID: (id: number) => string;
        readonly BY_MODEL: (modelId: string) => string;
        readonly PROVIDERS: "/modelprovidermapping/providers";
    };
    readonly IP_FILTERS: {
        readonly BASE: "/ipfilter";
        readonly BY_ID: (id: number) => string;
        readonly ENABLED: "/ipfilter/enabled";
        readonly SETTINGS: "/ipfilter/settings";
        readonly CHECK: "/ipfilter/check";
    };
    readonly MODEL_COSTS: {
        readonly BASE: "/modelcosts";
        readonly BY_ID: (id: number) => string;
        readonly BY_MODEL: (modelId: string) => string;
        readonly BATCH: "/modelcosts/batch";
    };
    readonly ANALYTICS: {
        readonly COST_SUMMARY: "/costdashboard/summary";
        readonly COST_BY_PERIOD: "/costdashboard/by-period";
        readonly COST_BY_MODEL: "/costdashboard/by-model";
        readonly COST_BY_KEY: "/costdashboard/by-key";
        readonly REQUEST_LOGS: "/logs";
        readonly REQUEST_LOG_BY_ID: (id: string) => string;
    };
    readonly HEALTH: {
        readonly CONFIGURATIONS: "/providerhealth/configurations";
        readonly CONFIG_BY_PROVIDER: (provider: string) => string;
        readonly STATUS: "/providerhealth/status";
        readonly STATUS_BY_PROVIDER: (provider: string) => string;
        readonly HISTORY: "/providerhealth/history";
        readonly CHECK: (provider: string) => string;
    };
    readonly SYSTEM: {
        readonly INFO: "/systeminfo/info";
        readonly HEALTH: "/systeminfo/health";
        readonly BACKUP: "/databasebackup";
        readonly RESTORE: "/databasebackup/restore";
        readonly NOTIFICATIONS: "/notifications";
        readonly NOTIFICATION_BY_ID: (id: number) => string;
    };
    readonly SETTINGS: {
        readonly GLOBAL: "/globalsettings";
        readonly GLOBAL_BY_KEY: (key: string) => string;
        readonly AUDIO: "/audioconfiguration";
        readonly AUDIO_BY_PROVIDER: (provider: string) => string;
        readonly ROUTER: "/router/configuration";
    };
};
declare const DEFAULT_PAGE_SIZE = 20;
declare const MAX_PAGE_SIZE = 100;
declare const CACHE_TTL: {
    readonly SHORT: 60;
    readonly MEDIUM: 300;
    readonly LONG: 3600;
    readonly VERY_LONG: 86400;
};
declare const HTTP_STATUS: {
    readonly OK: 200;
    readonly CREATED: 201;
    readonly NO_CONTENT: 204;
    readonly BAD_REQUEST: 400;
    readonly UNAUTHORIZED: 401;
    readonly FORBIDDEN: 403;
    readonly NOT_FOUND: 404;
    readonly CONFLICT: 409;
    readonly RATE_LIMITED: 429;
    readonly INTERNAL_ERROR: 500;
    readonly BAD_GATEWAY: 502;
    readonly SERVICE_UNAVAILABLE: 503;
    readonly GATEWAY_TIMEOUT: 504;
};
declare const BUDGET_DURATION: {
    readonly TOTAL: "Total";
    readonly DAILY: "Daily";
    readonly WEEKLY: "Weekly";
    readonly MONTHLY: "Monthly";
};
declare const FILTER_TYPE: {
    readonly ALLOW: "Allow";
    readonly DENY: "Deny";
};
declare const FILTER_MODE: {
    readonly PERMISSIVE: "permissive";
    readonly RESTRICTIVE: "restrictive";
};

export { API_PREFIX, API_VERSION, type AnalyticsFilters, AnalyticsService, type AnomalyDto, type ApiClientConfig, type ApiResponse, type AudioConfigurationDto, type AuditLogDto, type AuditLogFilters, AuthenticationError, AuthorizationError, type AxiosError, BUDGET_DURATION, type BackupDto, type BackupRestoreResult, type BudgetDuration, type BulkIpFilterRequest, type BulkIpFilterResponse, type BulkMappingRequest, type BulkMappingResponse, type BulkModelCostUpdate, CACHE_TTL, type CacheProvider, type CheckBudgetRequest, type CheckBudgetResponse, ConduitAdminClient, type ConduitConfig, ConduitError, ConflictError, type CostByPeriodDto, type CostEstimate, type CostForecastDto, type CostSummaryDto, type CreateAudioConfigurationDto, type CreateBackupRequest, type CreateGlobalSettingDto, type CreateIpFilterDto, type CreateModelCostDto, type CreateModelProviderMappingDto, type CreateNotificationDto, type CreateProviderCredentialDto, type CreateVirtualKeyRequest, type CreateVirtualKeyResponse, DEFAULT_PAGE_SIZE, type DateRange, ENDPOINTS, type ErrorResponse, FILTER_MODE, FILTER_TYPE, type FilterMode, type FilterOptions, type FilterType, type GlobalSettingDto, HTTP_STATUS, type HealthStatusDto, type HttpMethod, type IpCheckRequest, type IpCheckResult, type IpFilterDto, type IpFilterFilters, IpFilterService, type IpFilterSettingsDto, type IpFilterStatistics, type IpFilterValidationResult, type KeyUsageDto, type Logger, MAX_PAGE_SIZE, type MaintenanceTaskDto, type MaintenanceTaskResult, type ModelCostCalculation, type ModelCostComparison, type ModelCostDto, type ModelCostFilters, type ModelCostHistory, ModelCostService, type ModelMappingFilters, ModelMappingService, type ModelMappingSuggestion, type ModelProviderInfo, type ModelProviderMappingDto, type ModelRoutingInfo, type ModelUsageDto, NetworkError, NotFoundError, NotImplementedError, type NotificationDto, type PaginatedResponse, type ProviderConnectionTestRequest, type ProviderConnectionTestResultDto, type ProviderCredentialDto, type ProviderDataDto, type ProviderFilters, type ProviderHealthConfigurationDto, type ProviderHealthFilters, type ProviderHealthRecordDto, type ProviderHe