import type { Chain } from '@filoz/synapse-core/chains';
import type { PieceCID } from '@filoz/synapse-core/piece';
import type { Permission, SessionKey, SessionKeyAccount } from '@filoz/synapse-core/session-key';
import type { pullPiecesApiRequest } from '@filoz/synapse-core/sp';
import type { PDPProvider } from '@filoz/synapse-core/sp-registry';
import type { MetadataObject } from '@filoz/synapse-core/utils';
import type { getPriceList, getUploadCosts } from '@filoz/synapse-core/warm-storage';
import type { Account, Address, Client, Hash, Hex, Transport } from 'viem';
import type { Synapse } from './synapse.ts';
import type { WarmStorageService } from './warm-storage/service.ts';
export type { PDPProvider, PieceCID };
export type PullStatus = pullPiecesApiRequest.PullStatus;
export type PrivateKey = string;
export type TokenAmount = bigint;
export type DataSetId = bigint;
export type ServiceProvider = Address;
export type { RailInfo } from '@filoz/synapse-core/pay';
export type { MetadataEntry, MetadataObject } from '@filoz/synapse-core/utils';
export type { getPriceList, getUploadCosts };
export type UploadCosts = getUploadCosts.OutputType;
export type GetUploadCostsOptions = getUploadCosts.OptionsType;
export type FundOptions = import('@filoz/synapse-core/pay').fund.OptionsType;
export interface PrepareOptions {
    context?: import('./storage/context.ts').StorageContext | import('./storage/context.ts').StorageContext[];
    dataSize: bigint;
    extraRunwayEpochs?: bigint;
    bufferEpochs?: bigint;
    costs?: UploadCosts;
}
export interface PrepareResult {
    costs: UploadCosts;
    transaction: {
        depositAmount: bigint;
        includesApproval: boolean;
        execute: (options?: {
            onHash?: (hash: Hash) => void;
        }) => Promise<{
            hash: Hash;
            receipt: import('viem').TransactionReceipt | null;
        }>;
    } | null;
}
export type FilecoinNetworkType = 'mainnet' | 'calibration' | 'devnet';
export type TokenIdentifier = 'USDFC' | string;
export interface SynapseOptions {
    transport?: Transport;
    chain?: Chain;
    account: Account | Address;
    sessionKey?: SessionKey<'Secp256k1'>;
    requiredPermissions?: Permission[];
    withCDN?: boolean;
    source: string | null;
}
export interface SynapseFromClientOptions {
    client: Client<Transport, Chain, Account>;
    sessionClient?: Client<Transport, Chain, SessionKeyAccount<'Secp256k1'>>;
    withCDN?: boolean;
    source: string | null;
}
export interface StorageOptions {
    dataSetId?: DataSetId;
    serviceProvider?: ServiceProvider;
}
export interface UploadTask {
    pieceCid: () => Promise<PieceCID>;
    store: () => Promise<ServiceProvider>;
    done: () => Promise<string>;
}
export type DownloadOptions = {
    withCDN?: boolean;
    pieceCid: string | PieceCID;
};
export interface PieceFetchOptions {
    pieceCid: PieceCID;
    client: Address;
    providerAddress?: Address;
    withCDN?: boolean;
    signal?: AbortSignal;
}
export interface PieceRetriever {
    fetchPiece: (options: PieceFetchOptions) => Promise<Response>;
}
export interface DataSetInfo {
    pdpRailId: bigint;
    cacheMissRailId: bigint;
    cdnRailId: bigint;
    payer: Address;
    payee: Address;
    serviceProvider: Address;
    commissionBps: bigint;
    clientDataSetId: bigint;
    pdpEndEpoch: bigint;
    providerId: bigint;
    paymentEndEpoch?: bigint;
    dataSetId: bigint;
}
export interface EnhancedDataSetInfo extends DataSetInfo {
    pdpVerifierDataSetId: bigint;
    activePieceCount: bigint;
    isLive: boolean;
    isManaged: boolean;
    withCDN: boolean;
    metadata: Record<string, string>;
}
export interface SettlementResult {
    totalSettledAmount: bigint;
    totalNetPayeeAmount: bigint;
    totalOperatorCommission: bigint;
    totalNetworkFee: bigint;
    finalSettledEpoch: bigint;
    note: string;
}
export interface StorageContextCallbacks {
    onProviderSelected?: (provider: PDPProvider) => void;
    onDataSetResolved?: (info: {
        dataSetId: bigint;
        provider: PDPProvider;
    }) => void;
}
export interface BaseContextOptions {
    withCDN?: boolean;
    metadata?: Record<string, string>;
    callbacks?: StorageContextCallbacks;
}
export interface CreateContextsOptions extends BaseContextOptions {
    copies?: number;
    dataSetIds?: bigint[];
    providerIds?: bigint[];
    excludeProviderIds?: bigint[];
}
export interface ContextCreateContextsOptions extends CreateContextsOptions {
    synapse: Synapse;
    warmStorageService: WarmStorageService;
}
export interface StorageServiceOptions extends BaseContextOptions {
    providerId?: bigint;
    excludeProviderIds?: bigint[];
    dataSetId?: bigint;
}
export interface StorageContextCreateOptions extends StorageServiceOptions {
    synapse: Synapse;
    warmStorageService: WarmStorageService;
}
export interface UploadCallbacks {
    onProgress?: (bytesUploaded: number) => void;
    onStored?: (providerId: bigint, pieceCid: PieceCID) => void;
    onPiecesAdded?: (transaction: Hex, providerId: bigint, pieces: {
        pieceCid: PieceCID;
    }[]) => void;
    onPiecesConfirmed?: (dataSetId: bigint, providerId: bigint, pieces: PieceRecord[]) => void;
    onCopyComplete?: (providerId: bigint, pieceCid: PieceCID) => void;
    onCopyFailed?: (providerId: bigint, pieceCid: PieceCID, error: Error) => void;
    onPullProgress?: (providerId: bigint, pieceCid: PieceCID, status: PullStatus) => void;
}
export interface PieceRecord {
    pieceId: bigint;
    pieceCid: PieceCID;
}
export interface UploadOptions extends StoreOptions, UploadCallbacks {
    pieceMetadata?: MetadataObject;
}
export type CopyRole = 'primary' | 'secondary';
export interface CopyResult {
    providerId: bigint;
    dataSetId: bigint;
    pieceId: bigint;
    role: CopyRole;
    retrievalUrl: string;
    isNewDataSet: boolean;
}
export interface FailedAttempt {
    providerId: bigint;
    role: CopyRole;
    error: string;
    explicit: boolean;
}
export interface UploadResult {
    pieceCid: PieceCID;
    size: number;
    requestedCopies: number;
    complete: boolean;
    copies: CopyResult[];
    failedAttempts: FailedAttempt[];
}
export interface StoreOptions {
    pieceCid?: PieceCID;
    signal?: AbortSignal;
    onProgress?: (bytesUploaded: number) => void;
}
export interface StoreResult {
    pieceCid: PieceCID;
    size: number;
}
export type PullSource = string | ((pieceCid: PieceCID) => string);
export interface PullOptions {
    pieces: PieceCID[];
    from: PullSource;
    signal?: AbortSignal;
    onProgress?: (pieceCid: PieceCID, status: PullStatus) => void;
    extraData?: Hex;
}
export interface PullResult {
    status: 'complete' | 'failed';
    pieces: Array<{
        pieceCid: PieceCID;
        status: 'complete' | 'failed';
    }>;
}
export interface CommitOptions {
    pieces: Array<{
        pieceCid: PieceCID;
        pieceMetadata?: MetadataObject;
    }>;
    extraData?: Hex;
    onSubmitted?: (txHash: Hex) => void;
}
export interface CommitResult {
    txHash: Hex;
    pieceIds: bigint[];
    dataSetId: bigint;
    isNewDataSet: boolean;
}
export interface TerminateServiceOptions {
    dataSetId: bigint;
    skipProvider?: boolean;
    onSubmitted?: (txHash: Hex) => void;
}
export interface TerminateServiceResult {
    txHash?: Hex;
    dataSetId: bigint;
    endEpoch: bigint;
}
export interface StorageInfo {
    pricing: {
        noCDN: {
            perTiBPerMonth: bigint;
            perTiBPerDay: bigint;
            perTiBPerEpoch: bigint;
        };
        withCDN: {
            perTiBPerMonth: bigint;
            perTiBPerDay: bigint;
            perTiBPerEpoch: bigint;
        };
        tokenAddress: Address;
        tokenSymbol: string;
        priceList: getPriceList.OutputType;
    };
    providers: PDPProvider[];
    serviceParameters: {
        epochsPerMonth: bigint;
        epochsPerDay: bigint;
        epochDuration: number;
        minUploadSize: number;
        maxUploadSize: number;
    };
    allowances: {
        isApproved: boolean;
        service: Address;
        rateAllowance: bigint;
        lockupAllowance: bigint;
        rateUsed: bigint;
        lockupUsed: bigint;
        maxLockupPeriod: bigint;
    } | null;
}
export interface DataSetData {
    id: bigint;
    pieces: DataSetPieceData[];
    nextChallengeEpoch: number;
}
export interface DataSetPieceData {
    pieceId: bigint;
    pieceCid: PieceCID;
    subPieceCid: PieceCID;
    subPieceOffset: number;
}
export interface PieceStatus {
    dataSetLastProven: Date | null;
    dataSetNextProofDue: Date | null;
    retrievalUrl: string | null;
    pieceId?: bigint;
    inChallengeWindow?: boolean;
    hoursUntilChallengeWindow?: number;
    isProofOverdue?: boolean;
}
export interface ProviderSelectionResult {
    provider: PDPProvider;
    dataSetId: bigint | null;
    dataSetMetadata: Record<string, string>;
}
//# sourceMappingURL=types.d.ts.map