import { z, ZodError } from 'zod';
import { DateTime } from 'luxon';

declare const ApiErrorResponseSchema: z.ZodObject<{
    code: z.ZodString;
    message: z.ZodString;
}, z.core.$strip>;
type ApiErrorResponse = z.infer<typeof ApiErrorResponseSchema>;
type ResultSuccess<T> = {
    ok: true;
    data: T;
};
type ResultError<E> = {
    ok: false;
    error: E;
};
type Result<T, E = SdkError> = ResultSuccess<T> | ResultError<E>;
declare abstract class SdkError extends Error {
    abstract readonly type: string;
    abstract readonly retryable: boolean;
    readonly requestId?: string;
    readonly timestamp: Date;
    constructor(message: string, requestId?: string);
}
declare class NetworkError extends SdkError {
    readonly type: "network";
    readonly cause: Error;
    readonly retryable: boolean;
    readonly statusCode?: number;
    constructor(cause: Error, statusCode?: number, requestId?: string);
}
declare class ApiError extends SdkError {
    readonly type: "api";
    readonly subtype: "auth" | "rateLimit" | "notFound" | "unknown";
    readonly code: string;
    readonly originalMessage: string;
    readonly retryable: boolean;
    readonly demo?: boolean;
    constructor(apiError: ApiErrorResponse, demo?: boolean, requestId?: string);
}
declare class ValidationError extends SdkError {
    readonly type: "validation";
    readonly retryable = false;
    readonly issues: ZodError["issues"];
    constructor(zodError: ZodError, requestId?: string);
}
declare class ConfigurationError extends SdkError {
    readonly type: "configuration";
    readonly retryable = false;
    constructor(message: string);
}
interface BatchResult<T> {
    successes: T[];
    failures: SdkError[];
}
declare function createBatchResult<T>(results: Result<T, SdkError>[]): BatchResult<T>;

interface ParsedSuccessData<T> {
    data: T;
    demo: boolean;
}

declare const ClientOptionsSchema: z.ZodObject<{
    apiKey: z.ZodString;
    baseUrl: z.ZodOptional<z.ZodURL>;
    logLevel: z.ZodOptional<z.ZodEnum<{
        error: "error";
        fatal: "fatal";
        warn: "warn";
        info: "info";
        debug: "debug";
        trace: "trace";
    }>>;
    timeout: z.ZodOptional<z.ZodNumber>;
    retries: z.ZodOptional<z.ZodNumber>;
    maxContentLengthBytes: z.ZodOptional<z.ZodNumber>;
    maxBodyLengthBytes: z.ZodOptional<z.ZodNumber>;
    maxRedirects: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ClientOptions = z.infer<typeof ClientOptionsSchema>;
type RequestGetOptions = {
    method?: "GET";
    headers?: Record<string, string | number | boolean>;
    queryParams?: Record<string, string | number | boolean>;
    publicEndpoint?: boolean;
};
declare const RequestPostOptionsSchema: z.ZodObject<{
    requestType: z.ZodLiteral<"simplePost">;
    method: z.ZodLiteral<"POST">;
    headers: z.ZodOptional<z.ZodRecord<z.ZodUnion<readonly [z.ZodLiteral<"Accept">, z.ZodLiteral<"Content-Length">, z.ZodLiteral<"User-Agent">, z.ZodLiteral<"Content-Encoding">, z.ZodLiteral<"Authorization">, z.ZodString]>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
    queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
}, z.core.$strip>;
type RequestPostOptions = z.infer<typeof RequestPostOptionsSchema>;
declare const RequestPostJsonOptionsSchema: z.ZodObject<{
    method: z.ZodLiteral<"POST">;
    headers: z.ZodOptional<z.ZodRecord<z.ZodUnion<readonly [z.ZodLiteral<"Accept">, z.ZodLiteral<"Content-Length">, z.ZodLiteral<"User-Agent">, z.ZodLiteral<"Content-Encoding">, z.ZodLiteral<"Authorization">, z.ZodString]>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
    queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
    requestType: z.ZodLiteral<"postJson">;
    json: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>;
type RequestPostJsonOptions = z.infer<typeof RequestPostJsonOptionsSchema>;
declare const RequestPostFormDataOptionsSchema: z.ZodObject<{
    method: z.ZodLiteral<"POST">;
    headers: z.ZodOptional<z.ZodRecord<z.ZodUnion<readonly [z.ZodLiteral<"Accept">, z.ZodLiteral<"Content-Length">, z.ZodLiteral<"User-Agent">, z.ZodLiteral<"Content-Encoding">, z.ZodLiteral<"Authorization">, z.ZodString]>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
    queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
    requestType: z.ZodLiteral<"postFormData">;
    formData: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodCustom<FormData, FormData>]>;
}, z.core.$strip>;
type RequestPostFormDataOptions = z.infer<typeof RequestPostFormDataOptionsSchema>;
declare class AlldebridHttpClient {
    private baseUrl;
    private apiKey?;
    private timeout;
    private retries;
    private maxContentLengthBytes;
    private maxBodyLengthBytes;
    private maxRedirects;
    private normalizePath;
    private baseRequestSetup;
    private delay;
    configure(opts: ClientOptions): void;
    private executeRequest;
    getRequest<T extends z.ZodType>(path: string, dataSchema: T, options?: RequestGetOptions): Promise<ParsedSuccessData<z.output<T>>>;
    postRequest<T extends z.ZodType>(path: string, dataSchema: T, options?: RequestPostOptions | RequestPostFormDataOptions | RequestPostJsonOptions): Promise<ParsedSuccessData<z.output<T>>>;
}

declare const MagnetFileSchema: z.ZodObject<{
    n: z.ZodString;
    s: z.ZodInt;
    l: z.ZodURL;
}, z.core.$strip>;
type MagnetFile = z.infer<typeof MagnetFileSchema>;
declare const MagnetDirSchema: z.ZodObject<{
    n: z.ZodString;
    e: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
        n: z.ZodString;
        s: z.ZodInt;
        l: z.ZodURL;
    }, z.core.$strip>, z.ZodObject</*elided*/ any, z.core.$strip>]>>;
}, z.core.$strip>;
type MagnetDir = z.infer<typeof MagnetDirSchema>;
declare const MagnetListedReadySchema: z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    status: z.ZodLiteral<"Ready">;
    statusCode: z.ZodLiteral<4>;
    size: z.ZodInt;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    completionDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    nbLinks: z.ZodInt;
}, z.core.$strip>;
type MagnetListedReady = z.infer<typeof MagnetListedReadySchema>;
declare const MagnetListedErrorSchema: z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    status: z.ZodString;
    statusCode: z.ZodUnion<readonly [z.ZodLiteral<5>, z.ZodLiteral<6>, z.ZodLiteral<7>, z.ZodLiteral<8>, z.ZodLiteral<9>, z.ZodLiteral<10>, z.ZodLiteral<12>, z.ZodLiteral<13>, z.ZodLiteral<14>, z.ZodLiteral<15>]>;
    size: z.ZodPipe<z.ZodOptional<z.ZodInt>, z.ZodTransform<undefined, number | undefined>>;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number>>;
    completionDate: z.ZodPipe<z.ZodOptional<z.ZodInt>, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number | undefined>>;
}, z.core.$strip>;
type MagnetListedError = z.infer<typeof MagnetListedErrorSchema>;
declare const MagnetListedExpiredSchema: z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    status: z.ZodString;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number>>;
    completionDate: z.ZodPipe<z.ZodOptional<z.ZodInt>, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number | undefined>>;
    statusCode: z.ZodLiteral<11>;
    size: z.ZodInt;
}, z.core.$strip>;
type MagnetListedExpired = z.infer<typeof MagnetListedExpiredSchema>;
declare const MagnetListedSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    status: z.ZodLiteral<"Ready">;
    statusCode: z.ZodLiteral<4>;
    size: z.ZodInt;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    completionDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    nbLinks: z.ZodInt;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    downloaded: z.ZodInt;
    size: z.ZodInt;
    uploaded: z.ZodInt;
    seeders: z.ZodInt;
    downloadSpeed: z.ZodInt;
    processingPerc: z.ZodOptional<z.ZodInt>;
    uploadSpeed: z.ZodInt;
    status: z.ZodLiteral<"In Queue">;
    statusCode: z.ZodLiteral<0>;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    completionDate: z.ZodPipe<z.ZodLiteral<0>, z.ZodTransform<undefined, 0>>;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    downloaded: z.ZodInt;
    size: z.ZodInt;
    uploaded: z.ZodInt;
    seeders: z.ZodInt;
    downloadSpeed: z.ZodInt;
    processingPerc: z.ZodOptional<z.ZodInt>;
    uploadSpeed: z.ZodInt;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    completionDate: z.ZodPipe<z.ZodLiteral<0>, z.ZodTransform<undefined, 0>>;
    status: z.ZodLiteral<"Downloading">;
    statusCode: z.ZodLiteral<1>;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    downloaded: z.ZodInt;
    size: z.ZodInt;
    uploaded: z.ZodInt;
    seeders: z.ZodInt;
    downloadSpeed: z.ZodInt;
    processingPerc: z.ZodOptional<z.ZodInt>;
    uploadSpeed: z.ZodInt;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    completionDate: z.ZodPipe<z.ZodLiteral<0>, z.ZodTransform<undefined, 0>>;
    status: z.ZodLiteral<"Uploading">;
    statusCode: z.ZodLiteral<3>;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    status: z.ZodString;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number>>;
    completionDate: z.ZodPipe<z.ZodOptional<z.ZodInt>, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number | undefined>>;
    statusCode: z.ZodLiteral<11>;
    size: z.ZodInt;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    status: z.ZodString;
    statusCode: z.ZodUnion<readonly [z.ZodLiteral<5>, z.ZodLiteral<6>, z.ZodLiteral<7>, z.ZodLiteral<8>, z.ZodLiteral<9>, z.ZodLiteral<10>, z.ZodLiteral<12>, z.ZodLiteral<13>, z.ZodLiteral<14>, z.ZodLiteral<15>]>;
    size: z.ZodPipe<z.ZodOptional<z.ZodInt>, z.ZodTransform<undefined, number | undefined>>;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number>>;
    completionDate: z.ZodPipe<z.ZodOptional<z.ZodInt>, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number | undefined>>;
}, z.core.$strip>], "statusCode">;
type MagnetListed = z.infer<typeof MagnetListedSchema>;
declare const MagnetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    status: z.ZodLiteral<"Ready">;
    statusCode: z.ZodLiteral<4>;
    size: z.ZodInt;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    completionDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    nbLinks: z.ZodInt;
    files: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
        n: z.ZodString;
        s: z.ZodInt;
        l: z.ZodURL;
    }, z.core.$strip>, z.ZodObject<{
        n: z.ZodString;
        e: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
            n: z.ZodString;
            s: z.ZodInt;
            l: z.ZodURL;
        }, z.core.$strip>, z.ZodObject</*elided*/ any, z.core.$strip>]>>;
    }, z.core.$strip>]>>;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    downloaded: z.ZodInt;
    size: z.ZodInt;
    uploaded: z.ZodInt;
    seeders: z.ZodInt;
    downloadSpeed: z.ZodInt;
    processingPerc: z.ZodOptional<z.ZodInt>;
    uploadSpeed: z.ZodInt;
    status: z.ZodLiteral<"In Queue">;
    statusCode: z.ZodLiteral<0>;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    completionDate: z.ZodPipe<z.ZodLiteral<0>, z.ZodTransform<undefined, 0>>;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    downloaded: z.ZodInt;
    size: z.ZodInt;
    uploaded: z.ZodInt;
    seeders: z.ZodInt;
    downloadSpeed: z.ZodInt;
    processingPerc: z.ZodOptional<z.ZodInt>;
    uploadSpeed: z.ZodInt;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    completionDate: z.ZodPipe<z.ZodLiteral<0>, z.ZodTransform<undefined, 0>>;
    status: z.ZodLiteral<"Downloading">;
    statusCode: z.ZodLiteral<1>;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    downloaded: z.ZodInt;
    size: z.ZodInt;
    uploaded: z.ZodInt;
    seeders: z.ZodInt;
    downloadSpeed: z.ZodInt;
    processingPerc: z.ZodOptional<z.ZodInt>;
    uploadSpeed: z.ZodInt;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false>, number>>;
    completionDate: z.ZodPipe<z.ZodLiteral<0>, z.ZodTransform<undefined, 0>>;
    status: z.ZodLiteral<"Uploading">;
    statusCode: z.ZodLiteral<3>;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    status: z.ZodString;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number>>;
    completionDate: z.ZodPipe<z.ZodOptional<z.ZodInt>, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number | undefined>>;
    statusCode: z.ZodLiteral<11>;
    size: z.ZodInt;
}, z.core.$strip>, z.ZodObject<{
    id: z.ZodNumber;
    filename: z.ZodString;
    hash: z.ZodString;
    type: z.ZodOptional<z.ZodString>;
    notified: z.ZodOptional<z.ZodBoolean>;
    version: z.ZodOptional<z.ZodInt>;
    status: z.ZodString;
    statusCode: z.ZodUnion<readonly [z.ZodLiteral<5>, z.ZodLiteral<6>, z.ZodLiteral<7>, z.ZodLiteral<8>, z.ZodLiteral<9>, z.ZodLiteral<10>, z.ZodLiteral<12>, z.ZodLiteral<13>, z.ZodLiteral<14>, z.ZodLiteral<15>]>;
    size: z.ZodPipe<z.ZodOptional<z.ZodInt>, z.ZodTransform<undefined, number | undefined>>;
    uploadDate: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number>>;
    completionDate: z.ZodPipe<z.ZodOptional<z.ZodInt>, z.ZodTransform<DateTime<true> | DateTime<false> | undefined, number | undefined>>;
}, z.core.$strip>], "statusCode">;
type Magnet = z.infer<typeof MagnetSchema>;
declare const UploadedMagnetSuccessSchema: z.ZodObject<{
    name: z.ZodString;
    id: z.ZodInt;
    hash: z.ZodString;
    size: z.ZodInt;
    ready: z.ZodBoolean;
    magnet: z.ZodString;
}, z.core.$strip>;
type UploadedMagnetSuccess = z.infer<typeof UploadedMagnetSuccessSchema>;
declare const UploadedFileSuccessSchema: z.ZodObject<{
    name: z.ZodString;
    id: z.ZodInt;
    hash: z.ZodString;
    size: z.ZodInt;
    ready: z.ZodBoolean;
    file: z.ZodString;
}, z.core.$strip>;
type UploadedFileSuccess = z.infer<typeof UploadedFileSuccessSchema>;
declare const UploadedMagnetErroredSchema: z.ZodObject<{
    error: z.ZodObject<{
        code: z.ZodEnum<{
            MAGNET_NO_URI: "MAGNET_NO_URI";
            MAGNET_INVALID_URI: "MAGNET_INVALID_URI";
            MAGNET_MUST_BE_PREMIUM: "MAGNET_MUST_BE_PREMIUM";
            MAGNET_NO_SERVER: "MAGNET_NO_SERVER";
            MAGNET_TOO_MANY_ACTIVE: "MAGNET_TOO_MANY_ACTIVE";
        }>;
        message: z.ZodString;
    }, z.core.$strip>;
    magnet: z.ZodString;
}, z.core.$strip>;
type UploadedMagnetErrored = z.infer<typeof UploadedMagnetErroredSchema>;
declare const UploadedFileErroredSchema: z.ZodObject<{
    error: z.ZodObject<{
        code: z.ZodEnum<{
            MAGNET_NO_URI: "MAGNET_NO_URI";
            MAGNET_INVALID_URI: "MAGNET_INVALID_URI";
            MAGNET_MUST_BE_PREMIUM: "MAGNET_MUST_BE_PREMIUM";
            MAGNET_NO_SERVER: "MAGNET_NO_SERVER";
            MAGNET_TOO_MANY_ACTIVE: "MAGNET_TOO_MANY_ACTIVE";
        }>;
        message: z.ZodString;
    }, z.core.$strip>;
    file: z.ZodString;
}, z.core.$strip>;
type UploadedFileErrored = z.infer<typeof UploadedFileErroredSchema>;
declare const DeleteMagnetResponseSchema: z.ZodObject<{
    message: z.ZodString;
}, z.core.$strip>;
type DeleteMagnetResponse = z.infer<typeof DeleteMagnetResponseSchema>;
declare const RestartMagnetSuccessSchema: z.ZodObject<{
    magnet: z.ZodString;
    message: z.ZodString;
}, z.core.$strip>;
type RestartMagnetSuccess = z.infer<typeof RestartMagnetSuccessSchema>;
declare const RestartMagnetErroredSchema: z.ZodObject<{
    magnet: z.ZodString;
    error: z.ZodObject<{
        code: z.ZodEnum<{
            MAGNET_INVALID_ID: "MAGNET_INVALID_ID";
            MAGNET_PROCESSING: "MAGNET_PROCESSING";
        }>;
        message: z.ZodString;
    }, z.core.$strip>;
}, z.core.$strip>;
type RestartMagnetErrored = z.infer<typeof RestartMagnetErroredSchema>;

type InputTorrentFile = {
    fileName: string;
    blob: Blob;
};
declare class MagnetResource {
    private readonly client;
    constructor(client: AlldebridHttpClient);
    list(status: "active"): Promise<MagnetListedReady[]>;
    list(status: "ready"): Promise<MagnetListedReady[]>;
    list(status: "expired"): Promise<MagnetListedExpired[]>;
    list(status: "error"): Promise<MagnetListedError[]>;
    list(): Promise<MagnetListed[]>;
    get(id: number): Promise<Magnet>;
    upload(magnets: string): Promise<UploadedMagnetSuccess | UploadedMagnetErrored>;
    upload(magnets: string[]): Promise<BatchResult<UploadedMagnetSuccess | UploadedMagnetErrored>>;
    uploadFile(torrentFiles: InputTorrentFile): Promise<UploadedFileSuccess | UploadedFileErrored>;
    uploadFile(torrentFiles: InputTorrentFile[]): Promise<BatchResult<UploadedFileSuccess | UploadedFileErrored>>;
    delete(id: number): Promise<DeleteMagnetResponse>;
    restart(id: number): Promise<RestartMagnetSuccess | RestartMagnetErrored>;
    restart(ids: number[]): Promise<(RestartMagnetSuccess | RestartMagnetErrored)[]>;
}

declare const UserSchema: z.ZodObject<{
    username: z.ZodString;
    email: z.ZodEmail;
    isPremium: z.ZodBoolean;
    isSubscribed: z.ZodBoolean;
    isTrial: z.ZodBoolean;
    premiumUntil: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false> | null, number>>;
    lang: z.ZodString;
    preferedDomain: z.ZodString;
    fidelityPoints: z.ZodInt;
    limitedHostersQuotas: z.ZodRecord<z.ZodString, z.ZodInt>;
    remainingTrialQuota: z.ZodOptional<z.ZodInt>;
    notifications: z.ZodArray<z.ZodString>;
}, z.core.$strip>;
type User = z.infer<typeof UserSchema>;
declare const UserHostSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodEnum<{
        premium: "premium";
        free: "free";
    }>;
    domains: z.ZodArray<z.ZodString>;
    regexps: z.ZodArray<z.ZodString>;
    regexp: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
    status: z.ZodOptional<z.ZodBoolean>;
    quota: z.ZodOptional<z.ZodInt>;
    quotaMax: z.ZodOptional<z.ZodInt>;
    quotaType: z.ZodOptional<z.ZodString>;
    limitSimuDl: z.ZodOptional<z.ZodInt>;
}, z.core.$strip>;
type UserHost = z.infer<typeof UserHostSchema>;
declare const VerificationEmailStatusSchema: z.ZodObject<{
    verif: z.ZodEnum<{
        waiting: "waiting";
        allowed: "allowed";
        denied: "denied";
    }>;
    resendable: z.ZodOptional<z.ZodBoolean>;
    apikey: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type VarificationEmailStatus = z.infer<typeof VerificationEmailStatusSchema>;
declare const SavedLinkSchema: z.ZodObject<{
    link: z.ZodURL;
    filename: z.ZodString;
    date: z.ZodPipe<z.ZodInt, z.ZodTransform<DateTime<true> | DateTime<false> | null, number>>;
    size: z.ZodInt;
    host: z.ZodString;
}, z.core.$strip>;
type SavedLink = z.infer<typeof SavedLinkSchema>;

declare class UserResource {
    private readonly client;
    constructor(client: AlldebridHttpClient);
    get(): Promise<User>;
    getHosts(): Promise<Record<string, UserHost>>;
    checkVerificationToken(token: string): Promise<VarificationEmailStatus>;
    resendVerification(token: string): Promise<{
        sent: boolean;
    }>;
    clearNotifications(code: string): Promise<{
        code: string;
        cleared: boolean;
    }>;
    listSavedLinks(): Promise<SavedLink[]>;
    saveLinks(links: string[]): Promise<{
        saved: boolean;
    }>;
    deleteLinks(links: string[]): Promise<{
        deleted: boolean;
    }>;
    listRecentLinks(): Promise<SavedLink[]>;
    purgeRecentLinks(): Promise<{
        deleted: boolean;
    }>;
}

declare const ListHostResponseSchema: z.ZodObject<{
    hosts: z.ZodRecord<z.ZodString, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodEnum<{
            premium: "premium";
            free: "free";
        }>;
        domains: z.ZodArray<z.ZodString>;
        regexps: z.ZodArray<z.ZodString>;
        regexp: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
        status: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    streams: z.ZodRecord<z.ZodString, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodEnum<{
            premium: "premium";
            free: "free";
        }>;
        domains: z.ZodArray<z.ZodString>;
        regexps: z.ZodArray<z.ZodString>;
        regexp: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
        status: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    redirectors: z.ZodRecord<z.ZodString, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodEnum<{
            premium: "premium";
            free: "free";
        }>;
        domains: z.ZodArray<z.ZodString>;
        regexps: z.ZodArray<z.ZodString>;
        regexp: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
        status: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type ListHostResponse = z.infer<typeof ListHostResponseSchema>;
declare const ListDomainsResponseSchema: z.ZodObject<{
    hosts: z.ZodArray<z.ZodString>;
    streams: z.ZodArray<z.ZodString>;
    redirectors: z.ZodArray<z.ZodString>;
}, z.core.$strip>;
type ListDomainsResponse = z.infer<typeof ListDomainsResponseSchema>;
declare class HostResource {
    private readonly client;
    constructor(client: AlldebridHttpClient);
    list(): Promise<ListHostResponse>;
    listDomains(): Promise<ListDomainsResponse>;
    listHostPriorities(): Promise<Record<string, number>>;
}

declare const LinkInfoSchema: z.ZodUnion<readonly [z.ZodObject<{
    link: z.ZodURL;
    filename: z.ZodString;
    size: z.ZodInt;
    host: z.ZodString;
    hostDomain: z.ZodString;
}, z.core.$strip>, z.ZodObject<{
    link: z.ZodURL;
    error: z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
    }, z.core.$strip>;
}, z.core.$strip>]>;
type LinkInfo = z.infer<typeof LinkInfoSchema>;
declare const DebridLinkResponseSchema: z.ZodObject<{
    link: z.ZodURL;
    filename: z.ZodString;
    host: z.ZodString;
    streaming: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        ext: z.ZodString;
        quality: z.ZodUnion<readonly [z.ZodString, z.ZodInt]>;
        filesize: z.ZodInt;
        proto: z.ZodString;
        name: z.ZodString;
    }, z.core.$strip>>>;
    paws: z.ZodOptional<z.ZodBoolean>;
    filesize: z.ZodInt;
    id: z.ZodString;
    hostDomain: z.ZodString;
    delayed: z.ZodOptional<z.ZodInt>;
}, z.core.$strip>;
type DebridLinkResponse = z.infer<typeof DebridLinkResponseSchema>;

declare class LinkResource {
    private readonly client;
    constructor(client: AlldebridHttpClient);
    getInfo(link: string, password?: string): Promise<LinkInfo>;
    getInfo(links: string[], password?: string): Promise<LinkInfo[]>;
    debrid(link: string, password?: string): Promise<DebridLinkResponse>;
}

declare const HostSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodEnum<{
        premium: "premium";
        free: "free";
    }>;
    domains: z.ZodArray<z.ZodString>;
    regexps: z.ZodArray<z.ZodString>;
    regexp: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
    status: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type Host = z.infer<typeof HostSchema>;

declare class Alldebrid {
    private readonly httpClient;
    readonly magnet: MagnetResource;
    readonly user: UserResource;
    readonly host: HostResource;
    readonly link: LinkResource;
    constructor(opts: ClientOptions);
}

export { Alldebrid, ApiError, type BatchResult, type ClientOptions, ConfigurationError, type DebridLinkResponse, type DeleteMagnetResponse, type Host, type LinkInfo, type MagnetDir, type MagnetFile, type MagnetListed, type MagnetListedError, type MagnetListedExpired, type MagnetListedReady, NetworkError, type RestartMagnetErrored, type RestartMagnetSuccess, type SavedLink, SdkError, type UploadedFileErrored, type UploadedFileSuccess, type UploadedMagnetErrored, type UploadedMagnetSuccess, type User, type UserHost, ValidationError, type VarificationEmailStatus, createBatchResult };