@nativescript-community/ui-image/typings/fresco.d.ts

Advanced and efficient image display plugin which uses Fresco (Android) and SDWebImage (iOS) to implement caching, placeholders, image effects, and much more.

/* eslint-disable no-redeclare */
/* eslint-disable @typescript-eslint/adjacent-overload-signatures */
/* eslint-disable @typescript-eslint/unified-signatures */


declare namespace bolts {
    export class AggregateException {
        public static class: java.lang.Class<AggregateException>;
        /** @deprecated */
        public getErrors(): java.util.List<java.lang.Exception>;
        public constructor(param0: string, param1: java.util.List<any>);
        /** @deprecated */
        public getCauses(): native.Array<java.lang.Throwable>;
        public getInnerThrowables(): java.util.List<java.lang.Throwable>;
        public constructor(param0: java.util.List<any>);
        public printStackTrace(param0: java.io.PrintStream): void;
        public printStackTrace(param0: java.io.PrintWriter): void;
        public constructor(param0: string, param1: native.Array<java.lang.Throwable>);
    }
}

declare namespace bolts {
    export class AndroidExecutors {
        public static class: java.lang.Class<AndroidExecutors>;
        public static newCachedThreadPool(): java.util.concurrent.ExecutorService;
        public static newCachedThreadPool(param0: java.util.concurrent.ThreadFactory): java.util.concurrent.ExecutorService;
        public static allowCoreThreadTimeout(param0: java.util.concurrent.ThreadPoolExecutor, param1: boolean): void;
        public static uiThread(): java.util.concurrent.Executor;
    }
    export namespace AndroidExecutors {
        export class UIThreadExecutor {
            public static class: java.lang.Class<UIThreadExecutor>;
            public execute(param0: java.lang.Runnable): void;
        }
    }
}

declare namespace bolts {
    export class BoltsExecutors {
        public static class: java.lang.Class<BoltsExecutors>;
        public static background(): java.util.concurrent.ExecutorService;
    }
    export namespace BoltsExecutors {
        export class ImmediateExecutor {
            public static class: java.lang.Class<ImmediateExecutor>;
            public execute(param0: java.lang.Runnable): void;
        }
    }
}

declare namespace bolts {
    export class CancellationToken {
        public static class: java.lang.Class<CancellationToken>;
        public isCancellationRequested(): boolean;
        public toString(): string;
        public throwIfCancellationRequested(): void;
        public register(param0: java.lang.Runnable): CancellationTokenRegistration;
    }
}

declare namespace bolts {
    export class CancellationTokenRegistration {
        public static class: java.lang.Class<CancellationTokenRegistration>;
        public close(): void;
    }
}

declare namespace bolts {
    export class CancellationTokenSource {
        public static class: java.lang.Class<CancellationTokenSource>;
        public constructor();
        public close(): void;
        public isCancellationRequested(): boolean;
        public cancelAfter(param0: number): void;
        public toString(): string;
        public getToken(): CancellationToken;
        public cancel(): void;
    }
}

declare namespace bolts {
    export class Capture<T>  extends java.lang.Object {
        public static class: java.lang.Class<Capture<any>>;
        public constructor();
        public get(): T;
        public set(param0: T): void;
        public constructor(param0: T);
    }
}

declare namespace bolts {
    export class Continuation<TTaskResult, TContinuationResult>  extends java.lang.Object {
        public static class: java.lang.Class<Continuation<any,any>>;
        /**
		 * Constructs a new instance of the bolts.Continuation<any,any> interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
		 */
        public constructor(implementation: {
            then(param0: Task<TTaskResult>): TContinuationResult;
        });
        public constructor();
        public then(param0: Task<TTaskResult>): TContinuationResult;
    }
}

declare namespace bolts {
    export class ExecutorException {
        public static class: java.lang.Class<ExecutorException>;
        public constructor(param0: java.lang.Exception);
    }
}

declare namespace bolts {
    export class Task<TResult>  extends java.lang.Object {
        public static class: java.lang.Class<Task<any>>;
        public static BACKGROUND_EXECUTOR: java.util.concurrent.ExecutorService;
        public static UI_THREAD_EXECUTOR: java.util.concurrent.Executor;
        public continueWith(param0: Continuation<any,any>, param1: CancellationToken): Task<any>;
        public getResult(): TResult;
        public static whenAllResult(param0: java.util.Collection<any>): Task<any>;
        public static forError(param0: java.lang.Exception): Task<any>;
        public static getUnobservedExceptionHandler(): Task.UnobservedExceptionHandler;
        public getError(): java.lang.Exception;
        public static call(param0: java.util.concurrent.Callable<any>, param1: CancellationToken): Task<any>;
        public static cancelled(): Task<any>;
        public static forResult(param0: any): Task<any>;
        public static call(param0: java.util.concurrent.Callable<any>, param1: java.util.concurrent.Executor, param2: CancellationToken): Task<any>;
        public static call(param0: java.util.concurrent.Callable<any>): Task<any>;
        public continueWhile(param0: java.util.concurrent.Callable<java.lang.Boolean>, param1: Continuation<java.lang.Void,Task<java.lang.Void>>, param2: CancellationToken): Task<java.lang.Void>;
        public continueWithTask(param0: Continuation<any,any>, param1: java.util.concurrent.Executor, param2: CancellationToken): Task<any>;
        public static delay(param0: number): Task<java.lang.Void>;
        public static delay(param0: number, param1: CancellationToken): Task<java.lang.Void>;
        public onSuccessTask(param0: Continuation<any,any>): Task<any>;
        public static callInBackground(param0: java.util.concurrent.Callable<any>): Task<any>;
        public continueWhile(param0: java.util.concurrent.Callable<java.lang.Boolean>, param1: Continuation<java.lang.Void,Task<java.lang.Void>>, param2: java.util.concurrent.Executor, param3: CancellationToken): Task<java.lang.Void>;
        public static setUnobservedExceptionHandler(param0: Task.UnobservedExceptionHandler): void;
        public continueWithTask(param0: Continuation<any,any>): Task<any>;
        public onSuccessTask(param0: Continuation<any,any>, param1: CancellationToken): Task<any>;
        public onSuccess(param0: Continuation<any,any>, param1: java.util.concurrent.Executor): Task<any>;
        public onSuccess(param0: Continuation<any,any>, param1: CancellationToken): Task<any>;
        public continueWith(param0: Continuation<any,any>, param1: java.util.concurrent.Executor): Task<any>;
        public makeVoid(): Task<java.lang.Void>;
        public continueWith(param0: Continuation<any,any>): Task<any>;
        public continueWith(param0: Continuation<any,any>, param1: java.util.concurrent.Executor, param2: CancellationToken): Task<any>;
        public cast(): Task<any>;
        public static call(param0: java.util.concurrent.Callable<any>, param1: java.util.concurrent.Executor): Task<any>;
        public onSuccess(param0: Continuation<any,any>, param1: java.util.concurrent.Executor, param2: CancellationToken): Task<any>;
        public isFaulted(): boolean;
        public isCancelled(): boolean;
        public continueWhile(param0: java.util.concurrent.Callable<java.lang.Boolean>, param1: Continuation<java.lang.Void,Task<java.lang.Void>>, param2: java.util.concurrent.Executor): Task<java.lang.Void>;
        public continueWhile(param0: java.util.concurrent.Callable<java.lang.Boolean>, param1: Continuation<java.lang.Void,Task<java.lang.Void>>): Task<java.lang.Void>;
        public static whenAny(param0: java.util.Collection<any>): Task<Task<any>>;
        public static callInBackground(param0: java.util.concurrent.Callable<any>, param1: CancellationToken): Task<any>;
        public static whenAll(param0: java.util.Collection<any>): Task<java.lang.Void>;
        public waitForCompletion(param0: number, param1: java.util.concurrent.TimeUnit): boolean;
        public onSuccessTask(param0: Continuation<any,any>, param1: java.util.concurrent.Executor): Task<any>;
        /** @deprecated */
        public static create(): Task.TaskCompletionSource;
        public waitForCompletion(): void;
        public isCompleted(): boolean;
        public onSuccess(param0: Continuation<any,any>): Task<any>;
        public onSuccessTask(param0: Continuation<any,any>, param1: java.util.concurrent.Executor, param2: CancellationToken): Task<any>;
        public static whenAnyResult(param0: java.util.Collection<any>): Task<any>;
        public continueWithTask(param0: Continuation<any,any>, param1: java.util.concurrent.Executor): Task<any>;
        public continueWithTask(param0: Continuation<any,any>, param1: CancellationToken): Task<any>;
    }
    export namespace Task {
        export class TaskCompletionSource extends bolts.TaskCompletionSource<any> {
            public static class: java.lang.Class<TaskCompletionSource>;
        }
        export class UnobservedExceptionHandler {
            public static class: java.lang.Class<UnobservedExceptionHandler>;
            /**
			 * Constructs a new instance of the bolts.Task$UnobservedExceptionHandler interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
			 */
            public constructor(implementation: {
                unobservedException(param0: Task<any>, param1: UnobservedTaskException): void;
            });
            public constructor();
            public unobservedException(param0: Task<any>, param1: UnobservedTaskException): void;
        }
    }
}

declare namespace bolts {
    export class TaskCompletionSource<TResult>  extends java.lang.Object {
        public static class: java.lang.Class<TaskCompletionSource<any>>;
        public constructor();
        public getTask(): Task<TResult>;
        public trySetCancelled(): boolean;
        public setError(param0: java.lang.Exception): void;
        public setResult(param0: TResult): void;
        public trySetError(param0: java.lang.Exception): boolean;
        public setCancelled(): void;
        public trySetResult(param0: TResult): boolean;
    }
}

declare namespace bolts {
    export class UnobservedErrorNotifier {
        public static class: java.lang.Class<UnobservedErrorNotifier>;
        public setObserved(): void;
        public finalize(): void;
        public constructor(param0: Task<any>);
    }
}

declare namespace bolts {
    export class UnobservedTaskException {
        public static class: java.lang.Class<UnobservedTaskException>;
        public constructor(param0: java.lang.Throwable);
    }
}


declare namespace com {
    export namespace facebook {
        export namespace binaryresource {
            export class BinaryResource {
                public static class: java.lang.Class<BinaryResource>;
                /**
				 * Constructs a new instance of the com.facebook.binaryresource.BinaryResource interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
				 */
                public constructor(implementation: {
                    openStream(): java.io.InputStream;
                    read(): native.Array<number>;
                    size(): number;
                });
                public constructor();
                public read(): native.Array<number>;
                public openStream(): java.io.InputStream;
                public size(): number;
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace binaryresource {
            export class ByteArrayBinaryResource extends BinaryResource {
                public static class: java.lang.Class<ByteArrayBinaryResource>;
                public constructor(param0: native.Array<number>);
                public read(): native.Array<number>;
                public openStream(): java.io.InputStream;
                public size(): number;
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace binaryresource {
            export class FileBinaryResource extends BinaryResource {
                public static class: java.lang.Class<FileBinaryResource>;
                public static createOrNull(param0: java.io.File): FileBinaryResource;
                public read(): native.Array<number>;
                public hashCode(): number;
                public equals(param0: any): boolean;
                public getFile(): java.io.File;
                public openStream(): java.io.InputStream;
                public size(): number;
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class BaseCacheEventListener extends CacheEventListener {
                    public static class: java.lang.Class<BaseCacheEventListener>;
                    public onWriteAttempt(param0: CacheEvent): void;
                    public constructor();
                    public onHit(param0: CacheEvent): void;
                    public onCleared(): void;
                    public onMiss(param0: CacheEvent): void;
                    public onWriteException(param0: CacheEvent): void;
                    public onEviction(param0: CacheEvent): void;
                    public onReadException(param0: CacheEvent): void;
                    public onWriteSuccess(param0: CacheEvent): void;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class CacheErrorLogger {
                    public static class: java.lang.Class<CacheErrorLogger>;
                    /**
					 * Constructs a new instance of the com.facebook.cache.common.CacheErrorLogger interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
                    public constructor(implementation: {
                        logError(param0: CacheErrorLogger.CacheErrorCategory, param1: java.lang.Class<any>, param2: string, param3: java.lang.Throwable): void;
                    });
                    public constructor();
                    public logError(param0: CacheErrorLogger.CacheErrorCategory, param1: java.lang.Class<any>, param2: string, param3: java.lang.Throwable): void;
                }
                export namespace CacheErrorLogger {
                    export class CacheErrorCategory {
                        public static class: java.lang.Class<CacheErrorCategory>;
                        public static READ_DECODE: CacheErrorCategory;
                        public static READ_FILE: CacheErrorCategory;
                        public static READ_FILE_NOT_FOUND: CacheErrorCategory;
                        public static READ_INVALID_ENTRY: CacheErrorCategory;
                        public static WRITE_ENCODE: CacheErrorCategory;
                        public static WRITE_CREATE_TEMPFILE: CacheErrorCategory;
                        public static WRITE_UPDATE_FILE_NOT_FOUND: CacheErrorCategory;
                        public static WRITE_RENAME_FILE_TEMPFILE_NOT_FOUND: CacheErrorCategory;
                        public static WRITE_RENAME_FILE_TEMPFILE_PARENT_NOT_FOUND: CacheErrorCategory;
                        public static WRITE_RENAME_FILE_OTHER: CacheErrorCategory;
                        public static WRITE_CREATE_DIR: CacheErrorCategory;
                        public static WRITE_CALLBACK_ERROR: CacheErrorCategory;
                        public static WRITE_INVALID_ENTRY: CacheErrorCategory;
                        public static DELETE_FILE: CacheErrorCategory;
                        public static EVICTION: CacheErrorCategory;
                        public static GENERIC_IO: CacheErrorCategory;
                        public static OTHER: CacheErrorCategory;
                        public static values(): native.Array<CacheErrorCategory>;
                        public static valueOf(param0: string): CacheErrorCategory;
                    }
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class CacheEvent {
                    public static class: java.lang.Class<CacheEvent>;
                    /**
					 * Constructs a new instance of the com.facebook.cache.common.CacheEvent interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
                    public constructor(implementation: {
                        getCacheKey(): CacheKey;
                        getResourceId(): string;
                        getItemSize(): number;
                        getCacheSize(): number;
                        getCacheLimit(): number;
                        getException(): java.io.IOException;
                        getEvictionReason(): CacheEventListener.EvictionReason;
                    });
                    public constructor();
                    public getCacheLimit(): number;
                    public getCacheKey(): CacheKey;
                    public getItemSize(): number;
                    public getCacheSize(): number;
                    public getException(): java.io.IOException;
                    public getResourceId(): string;
                    public getEvictionReason(): CacheEventListener.EvictionReason;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class CacheEventListener {
                    public static class: java.lang.Class<CacheEventListener>;
                    /**
					 * Constructs a new instance of the com.facebook.cache.common.CacheEventListener interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
                    public constructor(implementation: {
                        onHit(param0: CacheEvent): void;
                        onMiss(param0: CacheEvent): void;
                        onWriteAttempt(param0: CacheEvent): void;
                        onWriteSuccess(param0: CacheEvent): void;
                        onReadException(param0: CacheEvent): void;
                        onWriteException(param0: CacheEvent): void;
                        onEviction(param0: CacheEvent): void;
                        onCleared(): void;
                    });
                    public constructor();
                    public onWriteAttempt(param0: CacheEvent): void;
                    public onHit(param0: CacheEvent): void;
                    public onCleared(): void;
                    public onMiss(param0: CacheEvent): void;
                    public onWriteException(param0: CacheEvent): void;
                    public onEviction(param0: CacheEvent): void;
                    public onReadException(param0: CacheEvent): void;
                    public onWriteSuccess(param0: CacheEvent): void;
                }
                export namespace CacheEventListener {
                    export class EvictionReason {
                        public static class: java.lang.Class<EvictionReason>;
                        public static CACHE_FULL: EvictionReason;
                        public static CONTENT_STALE: EvictionReason;
                        public static USER_FORCED: EvictionReason;
                        public static CACHE_MANAGER_TRIMMED: EvictionReason;
                        public static values(): native.Array<EvictionReason>;
                        public static valueOf(param0: string): EvictionReason;
                    }
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class CacheKey {
                    public static class: java.lang.Class<CacheKey>;
                    /**
					 * Constructs a new instance of the com.facebook.cache.common.CacheKey interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
                    public constructor(implementation: {
                        toString(): string;
                        equals(param0: any): boolean;
                        hashCode(): number;
                        containsUri(param0: globalAndroid.net.Uri): boolean;
                        getUriString(): string;
                    });
                    public constructor();
                    public equals(param0: any): boolean;
                    public getUriString(): string;
                    public toString(): string;
                    public containsUri(param0: globalAndroid.net.Uri): boolean;
                    public hashCode(): number;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class CacheKeyUtil {
                    public static class: java.lang.Class<CacheKeyUtil>;
                    public static getFirstResourceId(param0: CacheKey): string;
                    public constructor();
                    public static getResourceIds(param0: CacheKey): java.util.List<string>;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class DebuggingCacheKey extends SimpleCacheKey {
                    public static class: java.lang.Class<DebuggingCacheKey>;
                    public equals(param0: any): boolean;
                    public getUriString(): string;
                    public toString(): string;
                    public constructor(param0: string);
                    public containsUri(param0: globalAndroid.net.Uri): boolean;
                    public getCallerContext(): any;
                    public hashCode(): number;
                    public constructor(param0: string, param1: any, param2: globalAndroid.net.Uri);
                    public getSourceUri(): globalAndroid.net.Uri;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class MultiCacheKey extends CacheKey {
                    public static class: java.lang.Class<MultiCacheKey>;
                    public equals(param0: any): boolean;
                    public getUriString(): string;
                    public toString(): string;
                    public containsUri(param0: globalAndroid.net.Uri): boolean;
                    public getCacheKeys(): java.util.List<CacheKey>;
                    public hashCode(): number;
                    public constructor(param0: java.util.List<CacheKey>);
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class NoOpCacheErrorLogger extends CacheErrorLogger {
                    public static class: java.lang.Class<NoOpCacheErrorLogger>;
                    public logError(param0: CacheErrorLogger.CacheErrorCategory, param1: java.lang.Class<any>, param2: string, param3: java.lang.Throwable): void;
                    public static getInstance(): NoOpCacheErrorLogger;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class NoOpCacheEventListener extends CacheEventListener {
                    public static class: java.lang.Class<NoOpCacheEventListener>;
                    public onWriteAttempt(param0: CacheEvent): void;
                    public static getInstance(): NoOpCacheEventListener;
                    public onHit(param0: CacheEvent): void;
                    public onCleared(): void;
                    public onMiss(param0: CacheEvent): void;
                    public onWriteException(param0: CacheEvent): void;
                    public onEviction(param0: CacheEvent): void;
                    public onReadException(param0: CacheEvent): void;
                    public onWriteSuccess(param0: CacheEvent): void;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class SimpleCacheKey extends CacheKey {
                    public static class: java.lang.Class<SimpleCacheKey>;
                    public equals(param0: any): boolean;
                    public getUriString(): string;
                    public toString(): string;
                    public constructor(param0: string);
                    public containsUri(param0: globalAndroid.net.Uri): boolean;
                    public hashCode(): number;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class WriterCallback {
                    public static class: java.lang.Class<WriterCallback>;
                    /**
					 * Constructs a new instance of the com.facebook.cache.common.WriterCallback interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
                    public constructor(implementation: {
                        write(param0: java.io.OutputStream): void;
                    });
                    public constructor();
                    public write(param0: java.io.OutputStream): void;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace common {
                export class WriterCallbacks {
                    public static class: java.lang.Class<WriterCallbacks>;
                    public static from(param0: native.Array<number>): WriterCallback;
                    public constructor();
                    public static from(param0: java.io.InputStream): WriterCallback;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class DefaultDiskStorage extends DiskStorage {
                    public static class: java.lang.Class<DefaultDiskStorage>;
                    public getStorageName(): string;
                    public purgeUnexpectedResources(): void;
                    public insert(param0: string, param1: any): DiskStorage.Inserter;
                    public getDumpInfo(): DiskStorage.DiskDumpInfo;
                    public remove(param0: DiskStorage.Entry): number;
                    public getResource(param0: string, param1: any): binaryresource.BinaryResource;
                    public contains(param0: string, param1: any): boolean;
                    public isExternal(): boolean;
                    public touch(param0: string, param1: any): boolean;
                    public getEntries(): java.util.Collection<DiskStorage.Entry>;
                    public remove(param0: string): number;
                    public constructor(param0: java.io.File, param1: number, param2: common.CacheErrorLogger);
                    public clearAll(): void;
                    public isEnabled(): boolean;
                    public getEntries(): java.util.List<DiskStorage.Entry>;
                }
                export namespace DefaultDiskStorage {
                    export class EntriesCollector extends facebook.common.file.FileTreeVisitor {
                        public static class: java.lang.Class<EntriesCollector>;
                        public visitFile(param0: java.io.File): void;
                        public getEntries(): java.util.List<DiskStorage.Entry>;
                        public postVisitDirectory(param0: java.io.File): void;
                        public preVisitDirectory(param0: java.io.File): void;
                    }
                    export class EntryImpl extends DiskStorage.Entry {
                        public static class: java.lang.Class<EntryImpl>;
                        public getSize(): number;
                        public getTimestamp(): number;
                        public getResource(): binaryresource.BinaryResource;
                        public getId(): string;
                        public getResource(): binaryresource.FileBinaryResource;
                    }
                    export class FileInfo {
                        public static class: java.lang.Class<FileInfo>;
                        public type: string;
                        public resourceId: string;
                        public static fromFile(param0: java.io.File): FileInfo;
                        public toPath(param0: string): string;
                        public createTempFile(param0: java.io.File): java.io.File;
                        public toString(): string;
                    }
                    export class FileType {
                        public static class: java.lang.Class<FileType>;
                        /**
						 * Constructs a new instance of the com.facebook.cache.disk.DefaultDiskStorage$FileType interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
						 */
                        public constructor(implementation: {
                        });
                        public constructor();
                        public static TEMP: string;
                        public static CONTENT: string;
                    }
                    export class IncompleteFileException {
                        public static class: java.lang.Class<IncompleteFileException>;
                        public expected: number;
                        public actual: number;
                        public constructor(param0: number, param1: number);
                    }
                    export class InserterImpl extends DiskStorage.Inserter {
                        public static class: java.lang.Class<InserterImpl>;
                        public constructor(param0: DefaultDiskStorage, param1: string, param2: java.io.File);
                        public commit(param0: any): binaryresource.BinaryResource;
                        public writeData(param0: common.WriterCallback, param1: any): void;
                        public cleanUp(): boolean;
                    }
                    export class PurgingVisitor extends facebook.common.file.FileTreeVisitor {
                        public static class: java.lang.Class<PurgingVisitor>;
                        public visitFile(param0: java.io.File): void;
                        public postVisitDirectory(param0: java.io.File): void;
                        public preVisitDirectory(param0: java.io.File): void;
                    }
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class DefaultEntryEvictionComparatorSupplier extends EntryEvictionComparatorSupplier {
                    public static class: java.lang.Class<DefaultEntryEvictionComparatorSupplier>;
                    public constructor();
                    public get(): EntryEvictionComparator;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class DiskCacheConfig {
                    public static class: java.lang.Class<DiskCacheConfig>;
                    public getIndexPopulateAtStartupEnabled(): boolean;
                    public static newBuilder(param0: globalAndroid.content.Context): DiskCacheConfig.Builder;
                    public getVersion(): number;
                    public getMinimumSizeLimit(): number;
                    public getCacheErrorLogger(): common.CacheErrorLogger;
                    public getEntryEvictionComparatorSupplier(): EntryEvictionComparatorSupplier;
                    public getBaseDirectoryPathSupplier(): facebook.common.internal.Supplier<java.io.File>;
                    public getDefaultSizeLimit(): number;
                    public getLowDiskSpaceSizeLimit(): number;
                    public getCacheEventListener(): common.CacheEventListener;
                    public getDiskTrimmableRegistry(): facebook.common.disk.DiskTrimmableRegistry;
                    public getBaseDirectoryName(): string;
                    public getContext(): globalAndroid.content.Context;
                }
                export namespace DiskCacheConfig {
                    export class Builder {
                        public static class: java.lang.Class<Builder>;
                        public setMaxCacheSize(param0: number): Builder;
                        public setBaseDirectoryName(param0: string): Builder;
                        public build(): DiskCacheConfig;
                        public setDiskTrimmableRegistry(param0: facebook.common.disk.DiskTrimmableRegistry): Builder;
                        public setVersion(param0: number): Builder;
                        public setCacheErrorLogger(param0: common.CacheErrorLogger): Builder;
                        public setEntryEvictionComparatorSupplier(param0: EntryEvictionComparatorSupplier): Builder;
                        public setMaxCacheSizeOnVeryLowDiskSpace(param0: number): Builder;
                        public setIndexPopulateAtStartupEnabled(param0: boolean): Builder;
                        public setBaseDirectoryPath(param0: java.io.File): Builder;
                        public setBaseDirectoryPathSupplier(param0: facebook.common.internal.Supplier<java.io.File>): Builder;
                        public setMaxCacheSizeOnLowDiskSpace(param0: number): Builder;
                        public setCacheEventListener(param0: common.CacheEventListener): Builder;
                    }
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class DiskStorage {
                    public static class: java.lang.Class<DiskStorage>;
                    /**
					 * Constructs a new instance of the com.facebook.cache.disk.DiskStorage interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
                    public constructor(implementation: {
                        isEnabled(): boolean;
                        isExternal(): boolean;
                        getResource(param0: string, param1: any): binaryresource.BinaryResource;
                        contains(param0: string, param1: any): boolean;
                        touch(param0: string, param1: any): boolean;
                        purgeUnexpectedResources(): void;
                        insert(param0: string, param1: any): DiskStorage.Inserter;
                        getEntries(): java.util.Collection<DiskStorage.Entry>;
                        remove(param0: DiskStorage.Entry): number;
                        remove(param0: string): number;
                        clearAll(): void;
                        getDumpInfo(): DiskStorage.DiskDumpInfo;
                        getStorageName(): string;
                    });
                    public constructor();
                    public purgeUnexpectedResources(): void;
                    public insert(param0: string, param1: any): DiskStorage.Inserter;
                    public getDumpInfo(): DiskStorage.DiskDumpInfo;
                    public getStorageName(): string;
                    public remove(param0: DiskStorage.Entry): number;
                    public getResource(param0: string, param1: any): binaryresource.BinaryResource;
                    public contains(param0: string, param1: any): boolean;
                    public isExternal(): boolean;
                    public touch(param0: string, param1: any): boolean;
                    public getEntries(): java.util.Collection<DiskStorage.Entry>;
                    public remove(param0: string): number;
                    public clearAll(): void;
                    public isEnabled(): boolean;
                }
                export namespace DiskStorage {
                    export class DiskDumpInfo {
                        public static class: java.lang.Class<DiskDumpInfo>;
                        public entries: java.util.List<DiskDumpInfoEntry>;
                        public typeCounts: java.util.Map<string,java.lang.Integer>;
                        public constructor();
                    }
                    export class DiskDumpInfoEntry {
                        public static class: java.lang.Class<DiskDumpInfoEntry>;
                        public path: string;
                        public type: string;
                        public size: number;
                        public firstBits: string;
                        public constructor(param0: string, param1: string, param2: number, param3: string);
                    }
                    export class Entry {
                        public static class: java.lang.Class<Entry>;
                        /**
						 * Constructs a new instance of the com.facebook.cache.disk.DiskStorage$Entry interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
						 */
                        public constructor(implementation: {
                            getId(): string;
                            getTimestamp(): number;
                            getSize(): number;
                            getResource(): binaryresource.BinaryResource;
                        });
                        public constructor();
                        public getSize(): number;
                        public getTimestamp(): number;
                        public getResource(): binaryresource.BinaryResource;
                        public getId(): string;
                    }
                    export class Inserter {
                        public static class: java.lang.Class<Inserter>;
                        /**
						 * Constructs a new instance of the com.facebook.cache.disk.DiskStorage$Inserter interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
						 */
                        public constructor(implementation: {
                            writeData(param0: common.WriterCallback, param1: any): void;
                            commit(param0: any): binaryresource.BinaryResource;
                            cleanUp(): boolean;
                        });
                        public constructor();
                        public commit(param0: any): binaryresource.BinaryResource;
                        public writeData(param0: common.WriterCallback, param1: any): void;
                        public cleanUp(): boolean;
                    }
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class DiskStorageCache implements FileCache, facebook.common.disk.DiskTrimmable {
                    public static class: java.lang.Class<DiskStorageCache>;
                    public static START_OF_VERSIONING: number;
                    public hasKey(param0: common.CacheKey): boolean;
                    public awaitIndex(): void;
                    public isIndexReady(): boolean;
                    public getDumpInfo(): DiskStorage.DiskDumpInfo;
                    public probe(param0: common.CacheKey): boolean;
                    public getCount(): number;
                    public constructor(param0: DiskStorage, param1: EntryEvictionComparatorSupplier, param2: DiskStorageCache.Params, param3: common.CacheEventListener, param4: common.CacheErrorLogger, param5: facebook.common.disk.DiskTrimmableRegistry, param6: globalAndroid.content.Context, param7: java.util.concurrent.Executor, param8: boolean);
                    public trimToNothing(): void;
                    public hasKeySync(param0: common.CacheKey): boolean;
                    public getSize(): number;
                    public remove(param0: common.CacheKey): void;
                    public trimToMinimum(): void;
                    public getResource(param0: common.CacheKey): binaryresource.BinaryResource;
                    public insert(param0: common.CacheKey, param1: common.WriterCallback): binaryresource.BinaryResource;
                    public clearOldEntries(param0: number): number;
                    public clearAll(): void;
                    public isEnabled(): boolean;
                }
                export namespace DiskStorageCache {
                    export class CacheStats {
                        public static class: java.lang.Class<CacheStats>;
                        public increment(param0: number, param1: number): void;
                        public getSize(): number;
                        public set(param0: number, param1: number): void;
                        public getCount(): number;
                        public reset(): void;
                        public isInitialized(): boolean;
                    }
                    export class Params {
                        public static class: java.lang.Class<Params>;
                        public mCacheSizeLimitMinimum: number;
                        public mLowDiskSpaceCacheSizeLimit: number;
                        public mDefaultCacheSizeLimit: number;
                        public constructor(param0: number, param1: number, param2: number);
                    }
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class DynamicDefaultDiskStorage extends DiskStorage {
                    public static class: java.lang.Class<DynamicDefaultDiskStorage>;
                    public getStorageName(): string;
                    public purgeUnexpectedResources(): void;
                    public insert(param0: string, param1: any): DiskStorage.Inserter;
                    public getDumpInfo(): DiskStorage.DiskDumpInfo;
                    public remove(param0: DiskStorage.Entry): number;
                    public getResource(param0: string, param1: any): binaryresource.BinaryResource;
                    public contains(param0: string, param1: any): boolean;
                    public isExternal(): boolean;
                    public touch(param0: string, param1: any): boolean;
                    public getEntries(): java.util.Collection<DiskStorage.Entry>;
                    public remove(param0: string): number;
                    public clearAll(): void;
                    public isEnabled(): boolean;
                    public constructor(param0: number, param1: facebook.common.internal.Supplier<java.io.File>, param2: string, param3: common.CacheErrorLogger);
                }
                export namespace DynamicDefaultDiskStorage {
                    export class State {
                        public static class: java.lang.Class<State>;
                        public delegate: DiskStorage;
                        public rootDirectory: java.io.File;
                    }
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class EntryEvictionComparator extends java.util.Comparator<DiskStorage.Entry> {
                    public static class: java.lang.Class<EntryEvictionComparator>;
                    /**
					 * Constructs a new instance of the com.facebook.cache.disk.EntryEvictionComparator interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
                    public constructor(implementation: {
                    });
                    public constructor();
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class EntryEvictionComparatorSupplier {
                    public static class: java.lang.Class<EntryEvictionComparatorSupplier>;
                    /**
					 * Constructs a new instance of the com.facebook.cache.disk.EntryEvictionComparatorSupplier interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
                    public constructor(implementation: {
                        get(): EntryEvictionComparator;
                    });
                    public constructor();
                    public get(): EntryEvictionComparator;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class FileCache extends facebook.common.disk.DiskTrimmable {
                    public static class: java.lang.Class<FileCache>;
                    /**
					 * Constructs a new instance of the com.facebook.cache.disk.FileCache interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
                    public constructor(implementation: {
                        isEnabled(): boolean;
                        getResource(param0: common.CacheKey): binaryresource.BinaryResource;
                        hasKeySync(param0: common.CacheKey): boolean;
                        hasKey(param0: common.CacheKey): boolean;
                        probe(param0: common.CacheKey): boolean;
                        insert(param0: common.CacheKey, param1: common.WriterCallback): binaryresource.BinaryResource;
                        remove(param0: common.CacheKey): void;
                        getSize(): number;
                        getCount(): number;
                        clearOldEntries(param0: number): number;
                        clearAll(): void;
                        getDumpInfo(): DiskStorage.DiskDumpInfo;
                        trimToMinimum(): void;
                        trimToNothing(): void;
                    });
                    public constructor();
                    public hasKey(param0: common.CacheKey): boolean;
                    public getDumpInfo(): DiskStorage.DiskDumpInfo;
                    public probe(param0: common.CacheKey): boolean;
                    public getCount(): number;
                    public trimToNothing(): void;
                    public hasKeySync(param0: common.CacheKey): boolean;
                    public getSize(): number;
                    public remove(param0: common.CacheKey): void;
                    public trimToMinimum(): void;
                    public getResource(param0: common.CacheKey): binaryresource.BinaryResource;
                    public insert(param0: common.CacheKey, param1: common.WriterCallback): binaryresource.BinaryResource;
                    public clearOldEntries(param0: number): number;
                    public clearAll(): void;
                    public isEnabled(): boolean;
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class ScoreBasedEvictionComparatorSupplier extends EntryEvictionComparatorSupplier {
                    public static class: java.lang.Class<ScoreBasedEvictionComparatorSupplier>;
                    public get(): EntryEvictionComparator;
                    public constructor(param0: number, param1: number);
                }
            }
        }
    }
}

declare namespace com {
    export namespace facebook {
        export namespace cache {
            export namespace disk {
                export class SettableCacheEvent extends common.CacheEvent {
                    public static class: java.lang.Class<SettableCacheEvent>;
                    public getCacheLimit(): number;
                    public getItemSize(): number;
                    public getCacheSize(): number;
                    public setEvictionReason(param0: common.CacheEventListener.EvictionReason): SettableCacheEvent;
                    public setCacheKey(param0: common.CacheKey): SettableCacheEvent;
                    public getResourceId(): string;
                    public recycle(): void;
                    pu