@sm003/autojs6-dts/declarations/libraries/net.lingala.zip4j-zip4j-2.11.5.d.ts

TypeScript Declarations for AutoJs6

declare module net {
	export module lingala {
		export module zip4j {
			export class ZipFile extends java.lang.Object implements java.io.Closeable {
				public static class: java.lang.Class<net.lingala.zip4j.ZipFile>;
				public extractFile(fileName: string, destinationPath: string, newFileName: string): void;
				public renameFile(fileNameToRename: string, newFileName: string): void;
				public setThreadFactory(threadFactory: java.util.concurrent.ThreadFactory): void;
				public getSplitZipFiles(): java.util.List<java.io.File>;
				public isRunInThread(): boolean;
				public constructor(zipFile: string);
				public extractFile(fileHeader: net.lingala.zip4j.model.FileHeader, destinationPath: string, unzipParameters: net.lingala.zip4j.model.UnzipParameters): void;
				public setRunInThread(runInThread: boolean): void;
				public createSplitZipFile(filesToAdd: java.util.List<java.io.File>, parameters: net.lingala.zip4j.model.ZipParameters, splitArchive: boolean, splitLength: number): void;
				public renameFile(fileHeader: net.lingala.zip4j.model.FileHeader, newFileName: string): void;
				public renameFiles(fileNamesMap: java.util.Map<string,string>): void;
				public setComment(comment: string): void;
				public extractAll(destinationPath: string): void;
				public addStream(inputStream: java.io.InputStream, parameters: net.lingala.zip4j.model.ZipParameters): void;
				public extractAll(destinationPath: string, unzipParameters: net.lingala.zip4j.model.UnzipParameters): void;
				public extractFile(fileHeader: net.lingala.zip4j.model.FileHeader, destinationPath: string): void;
				public getCharset(): java.nio.charset.Charset;
				public getComment(): string;
				public isSplitArchive(): boolean;
				public close(): void;
				public getExecutorService(): java.util.concurrent.ExecutorService;
				public getProgressMonitor(): net.lingala.zip4j.progress.ProgressMonitor;
				public toString(): string;
				public addFile(fileToAdd: java.io.File): void;
				public setBufferSize(bufferSize: number): void;
				public setPassword(password: string[]): void;
				public constructor(zipFile: java.io.File);
				public getBufferSize(): number;
				public mergeSplitFiles(outputZipFile: java.io.File): void;
				public constructor(zipFile: string, password: string[]);
				public setCharset(charset: java.nio.charset.Charset): void;
				public getFileHeaders(): java.util.List<net.lingala.zip4j.model.FileHeader>;
				public isUseUtf8CharsetForPasswords(): boolean;
				public extractFile(fileName: string, destinationPath: string, unzipParameters: net.lingala.zip4j.model.UnzipParameters): void;
				public setUseUtf8CharsetForPasswords(useUtf8CharsetForPasswords: boolean): void;
				public constructor(zipFile: java.io.File, password: string[]);
				public removeFile(fileHeader: net.lingala.zip4j.model.FileHeader): void;
				public removeFiles(fileNames: java.util.List<string>): void;
				public addFolder(folderToAdd: java.io.File, zipParameters: net.lingala.zip4j.model.ZipParameters): void;
				public addFile(fileToAdd: string, zipParameters: net.lingala.zip4j.model.ZipParameters): void;
				public getInputStream(fileHeader: net.lingala.zip4j.model.FileHeader): net.lingala.zip4j.io.inputstream.ZipInputStream;
				public addFiles(filesToAdd: java.util.List<java.io.File>, parameters: net.lingala.zip4j.model.ZipParameters): void;
				public extractFile(fileName: string, destinationPath: string, newFileName: string, unzipParameters: net.lingala.zip4j.model.UnzipParameters): void;
				public extractFile(fileHeader: net.lingala.zip4j.model.FileHeader, destinationPath: string, newFileName: string, unzipParameters: net.lingala.zip4j.model.UnzipParameters): void;
				public isValidZipFile(): boolean;
				public removeFile(fileName: string): void;
				public extractFile(fileName: string, destinationPath: string): void;
				public addFolder(folderToAdd: java.io.File): void;
				public addFile(fileToAdd: string): void;
				public addFile(fileToAdd: java.io.File, parameters: net.lingala.zip4j.model.ZipParameters): void;
				public extractFile(fileHeader: net.lingala.zip4j.model.FileHeader, destinationPath: string, newFileName: string): void;
				public createSplitZipFileFromFolder(folderToAdd: java.io.File, parameters: net.lingala.zip4j.model.ZipParameters, splitArchive: boolean, splitLength: number): void;
				public getFile(): java.io.File;
				public getFileHeader(fileName: string): net.lingala.zip4j.model.FileHeader;
				public addFiles(filesToAdd: java.util.List<java.io.File>): void;
				public isEncrypted(): boolean;
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export class AESDecrypter extends java.lang.Object implements net.lingala.zip4j.crypto.Decrypter {
					public static class: java.lang.Class<net.lingala.zip4j.crypto.AESDecrypter>;
					public getCalculatedAuthenticationBytes(numberOfBytesPushedBack: number): number[];
					public constructor(aesExtraDataRecord: net.lingala.zip4j.model.AESExtraDataRecord, password: string[], salt: number[], passwordVerifier: number[], useUtf8ForPassword: boolean);
					public decryptData(buff: number[], start: number, len: number): number;
					public decryptData(param0: number[], param1: number, param2: number): number;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export class AESEncrypter extends java.lang.Object implements net.lingala.zip4j.crypto.Encrypter {
					public static class: java.lang.Class<net.lingala.zip4j.crypto.AESEncrypter>;
					public getFinalMac(): number[];
					public getDerivedPasswordVerifier(): number[];
					public encryptData(buff: number[]): number;
					public getSaltBytes(): number[];
					public constructor(password: string[], aesKeyStrength: net.lingala.zip4j.model.enums.AesKeyStrength, useUtf8ForPassword: boolean);
					public encryptData(param0: number[]): number;
					public encryptData(buff: number[], start: number, len: number): number;
					public encryptData(param0: number[], param1: number, param2: number): number;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export class AesCipherUtil extends java.lang.Object {
					public static class: java.lang.Class<net.lingala.zip4j.crypto.AesCipherUtil>;
					public static derivePasswordVerifier(derivedKey: number[], aesKeyStrength: net.lingala.zip4j.model.enums.AesKeyStrength): number[];
					public static getMacBasedPRF(derivedKey: number[], aesKeyStrength: net.lingala.zip4j.model.enums.AesKeyStrength): net.lingala.zip4j.crypto.PBKDF2.MacBasedPRF;
					public constructor();
					public static getAESEngine(derivedKey: number[], aesKeyStrength: net.lingala.zip4j.model.enums.AesKeyStrength): net.lingala.zip4j.crypto.engine.AESEngine;
					public static prepareBuffAESIVBytes(buff: number[], nonce: number): void;
					public static derivePasswordBasedKey(salt: number[], password: string[], aesKeyStrength: net.lingala.zip4j.model.enums.AesKeyStrength, useUtf8ForPassword: boolean): number[];
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export class Decrypter extends java.lang.Object {
					public static class: java.lang.Class<net.lingala.zip4j.crypto.Decrypter>;
					/**
					 * Constructs a new instance of the net.lingala.zip4j.crypto.Decrypter interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
					public constructor(implementation: {
						decryptData(param0: number[], param1: number, param2: number): number;
					});
					public constructor();
					public decryptData(param0: number[], param1: number, param2: number): number;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export class Encrypter extends java.lang.Object {
					public static class: java.lang.Class<net.lingala.zip4j.crypto.Encrypter>;
					/**
					 * Constructs a new instance of the net.lingala.zip4j.crypto.Encrypter interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
					 */
					public constructor(implementation: {
						encryptData(param0: number[]): number;
						encryptData(param0: number[], param1: number, param2: number): number;
					});
					public constructor();
					public encryptData(param0: number[]): number;
					public encryptData(param0: number[], param1: number, param2: number): number;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export module PBKDF2 {
					export class BinTools extends java.lang.Object {
						public static class: java.lang.Class<net.lingala.zip4j.crypto.PBKDF2.BinTools>;
						public static hex: string;
						public static bin2hex(b: number[]): string;
						public static hex2bin(c: string): number;
						public static hex2bin(s: string): number[];
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export module PBKDF2 {
					export class MacBasedPRF extends java.lang.Object implements net.lingala.zip4j.crypto.PBKDF2.PRF {
						public static class: java.lang.Class<net.lingala.zip4j.crypto.PBKDF2.MacBasedPRF>;
						public doFinal(numberOfBytesToPushbackForMac: number): number[];
						public update(u: number[], start: number, len: number): void;
						public doFinal(M: number[]): number[];
						public update(u: number[]): void;
						public constructor(macAlgorithm: string);
						public init(P: number[]): void;
						public doFinal(): number[];
						public doFinal(param0: number[]): number[];
						public getHLen(): number;
						public init(param0: number[]): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export module PBKDF2 {
					export class PBKDF2Engine extends java.lang.Object {
						public static class: java.lang.Class<net.lingala.zip4j.crypto.PBKDF2.PBKDF2Engine>;
						public getParameters(): net.lingala.zip4j.crypto.PBKDF2.PBKDF2Parameters;
						public constructor(parameters: net.lingala.zip4j.crypto.PBKDF2.PBKDF2Parameters);
						public setParameters(parameters: net.lingala.zip4j.crypto.PBKDF2.PBKDF2Parameters): void;
						public deriveKey(inputPassword: string[], dkLen: number, useUtf8ForPassword: boolean): number[];
						public constructor(parameters: net.lingala.zip4j.crypto.PBKDF2.PBKDF2Parameters, prf: net.lingala.zip4j.crypto.PBKDF2.PRF);
						public INT(dest: number[], offset: number, i: number): void;
						public setPseudoRandomFunction(prf: net.lingala.zip4j.crypto.PBKDF2.PRF): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export module PBKDF2 {
					export class PBKDF2HexFormatter extends java.lang.Object {
						public static class: java.lang.Class<net.lingala.zip4j.crypto.PBKDF2.PBKDF2HexFormatter>;
						public toString(p: net.lingala.zip4j.crypto.PBKDF2.PBKDF2Parameters): string;
						public fromString(p: net.lingala.zip4j.crypto.PBKDF2.PBKDF2Parameters, s: string): boolean;
						public toString(): string;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export module PBKDF2 {
					export class PBKDF2Parameters extends java.lang.Object {
						public static class: java.lang.Class<net.lingala.zip4j.crypto.PBKDF2.PBKDF2Parameters>;
						public salt: number[];
						public iterationCount: number;
						public hashAlgorithm: string;
						public hashCharset: string;
						public derivedKey: number[];
						public constructor();
						public getIterationCount(): number;
						public getHashCharset(): string;
						public setHashCharset(hashCharset: string): void;
						public getDerivedKey(): number[];
						public getHashAlgorithm(): string;
						public constructor(hashAlgorithm: string, hashCharset: string, salt: number[], iterationCount: number, derivedKey: number[]);
						public setSalt(salt: number[]): void;
						public setIterationCount(iterationCount: number): void;
						public constructor(hashAlgorithm: string, hashCharset: string, salt: number[], iterationCount: number);
						public setDerivedKey(derivedKey: number[]): void;
						public setHashAlgorithm(hashAlgorithm: string): void;
						public getSalt(): number[];
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export module PBKDF2 {
					export class PRF extends java.lang.Object {
						public static class: java.lang.Class<net.lingala.zip4j.crypto.PBKDF2.PRF>;
						/**
						 * Constructs a new instance of the net.lingala.zip4j.crypto.PBKDF2.PRF interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
						 */
						public constructor(implementation: {
							init(param0: number[]): void;
							doFinal(param0: number[]): number[];
							getHLen(): number;
						});
						public constructor();
						public doFinal(param0: number[]): number[];
						public init(param0: number[]): void;
						public getHLen(): number;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export class StandardDecrypter extends java.lang.Object implements net.lingala.zip4j.crypto.Decrypter {
					public static class: java.lang.Class<net.lingala.zip4j.crypto.StandardDecrypter>;
					public decryptData(buff: number[], start: number, len: number): number;
					public decryptData(param0: number[], param1: number, param2: number): number;
					public constructor(password: string[], crc: number, param2: number, lastModifiedFileTime: number[], param4: boolean);
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export class StandardEncrypter extends java.lang.Object implements net.lingala.zip4j.crypto.Encrypter {
					public static class: java.lang.Class<net.lingala.zip4j.crypto.StandardEncrypter>;
					public encryptData(buff: number[]): number;
					public generateRandomBytes(): number[];
					public constructor(password: string[], key: number, param2: boolean);
					public getHeaderBytes(): number[];
					public encryptByte(val: number): number;
					public encryptData(param0: number[]): number;
					public encryptData(buff: number[], start: number, len: number): number;
					public encryptData(param0: number[], param1: number, param2: number): number;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export module engine {
					export class AESEngine extends java.lang.Object {
						public static class: java.lang.Class<net.lingala.zip4j.crypto.engine.AESEngine>;
						public constructor(key: number[]);
						public processBlock(_in_: number[], inOff: number, out: number[], outOff: number): number;
						public processBlock(_in_: number[], out: number[]): number;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module crypto {
				export module engine {
					export class ZipCryptoEngine extends java.lang.Object {
						public static class: java.lang.Class<net.lingala.zip4j.crypto.engine.ZipCryptoEngine>;
						public constructor();
						public initKeys(password: string[], useUtf8ForPassword: boolean): void;
						public updateKeys(charAt: number): void;
						public decryptByte(): number;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module exception {
				export class ZipException extends java.io.IOException {
					public static class: java.lang.Class<net.lingala.zip4j.exception.ZipException>;
					public constructor(message: string);
					public constructor(message: string, cause: java.lang.Throwable, enableSuppression: boolean, writableStackTrace: boolean);
					public constructor(message: string, rootException: java.lang.Exception);
					public constructor(message: string, type: net.lingala.zip4j.exception.ZipException.Type);
					public constructor(message: string, throwable: java.lang.Throwable, type: net.lingala.zip4j.exception.ZipException.Type);
					public constructor();
					public constructor(cause: java.lang.Throwable);
					public getType(): net.lingala.zip4j.exception.ZipException.Type;
					public constructor(message: string, cause: java.lang.Throwable);
					public constructor(rootException: java.lang.Exception);
				}
				export module ZipException {
					export class Type {
						public static class: java.lang.Class<net.lingala.zip4j.exception.ZipException.Type>;
						public static WRONG_PASSWORD: net.lingala.zip4j.exception.ZipException.Type;
						public static TASK_CANCELLED_EXCEPTION: net.lingala.zip4j.exception.ZipException.Type;
						public static CHECKSUM_MISMATCH: net.lingala.zip4j.exception.ZipException.Type;
						public static UNKNOWN_COMPRESSION_METHOD: net.lingala.zip4j.exception.ZipException.Type;
						public static FILE_NOT_FOUND: net.lingala.zip4j.exception.ZipException.Type;
						public static UNSUPPORTED_ENCRYPTION: net.lingala.zip4j.exception.ZipException.Type;
						public static UNKNOWN: net.lingala.zip4j.exception.ZipException.Type;
						public static valueOf(enumType: java.lang.Class<any>, name: string): java.lang.Enum<any>;
						public static values(): net.lingala.zip4j.exception.ZipException.Type[];
						public static valueOf(name: string): net.lingala.zip4j.exception.ZipException.Type;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module headers {
				export class FileHeaderFactory extends java.lang.Object {
					public static class: java.lang.Class<net.lingala.zip4j.headers.FileHeaderFactory>;
					public generateLocalFileHeader(fileHeader: net.lingala.zip4j.model.FileHeader): net.lingala.zip4j.model.LocalFileHeader;
					public constructor();
					public generateFileHeader(zipParameters: net.lingala.zip4j.model.ZipParameters, isSplitZip: boolean, currentDiskNumberStart: number, charset: java.nio.charset.Charset, rawIO: net.lingala.zip4j.util.RawIO): net.lingala.zip4j.model.FileHeader;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module headers {
				export class HeaderReader extends java.lang.Object {
					public static class: java.lang.Class<net.lingala.zip4j.headers.HeaderReader>;
					public constructor();
					public readAllHeaders(zip4jRaf: java.io.RandomAccessFile, zip4jConfig: net.lingala.zip4j.model.Zip4jConfig): net.lingala.zip4j.model.ZipModel;
					public readDataDescriptor(inputStream: java.io.InputStream, isZip64Format: boolean): net.lingala.zip4j.model.DataDescriptor;
					public isDirectory(externalFileAttributes: number[], fileName: string): boolean;
					public readLocalFileHeader(inputStream: java.io.InputStream, charset: java.nio.charset.Charset): net.lingala.zip4j.model.LocalFileHeader;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module headers {
				export class HeaderSignature {
					public static class: java.lang.Class<net.lingala.zip4j.headers.HeaderSignature>;
					public static LOCAL_FILE_HEADER: net.lingala.zip4j.headers.HeaderSignature;
					public static EXTRA_DATA_RECORD: net.lingala.zip4j.headers.HeaderSignature;
					public static CENTRAL_DIRECTORY: net.lingala.zip4j.headers.HeaderSignature;
					public static END_OF_CENTRAL_DIRECTORY: net.lingala.zip4j.headers.HeaderSignature;
					public static TEMPORARY_SPANNING_MARKER: net.lingala.zip4j.headers.HeaderSignature;
					public static DIGITAL_SIGNATURE: net.lingala.zip4j.headers.HeaderSignature;
					public static ARCEXTDATREC: net.lingala.zip4j.headers.HeaderSignature;
					public static SPLIT_ZIP: net.lingala.zip4j.headers.HeaderSignature;
					public static ZIP64_END_CENTRAL_DIRECTORY_LOCATOR: net.lingala.zip4j.headers.HeaderSignature;
					public static ZIP64_END_CENTRAL_DIRECTORY_RECORD: net.lingala.zip4j.headers.HeaderSignature;
					public static ZIP64_EXTRA_FIELD_SIGNATURE: net.lingala.zip4j.headers.HeaderSignature;
					public static AES_EXTRA_DATA_RECORD: net.lingala.zip4j.headers.HeaderSignature;
					public static valueOf(enumType: java.lang.Class<any>, name: string): java.lang.Enum<any>;
					public getValue(): number;
					public static values(): net.lingala.zip4j.headers.HeaderSignature[];
					public static valueOf(name: string): net.lingala.zip4j.headers.HeaderSignature;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module headers {
				export class HeaderUtil extends java.lang.Object {
					public static class: java.lang.Class<net.lingala.zip4j.headers.HeaderUtil>;
					public static decodeStringWithCharset(data: number[], isUtf8Encoded: boolean, charset: java.nio.charset.Charset): string;
					public static getBytesFromString(string: string, charset: java.nio.charset.Charset): number[];
					public static getTotalUncompressedSizeOfAllFileHeaders(fileHeaders: java.util.List<net.lingala.zip4j.model.FileHeader>): number;
					public constructor();
					public static getFileHeadersUnderDirectory(allFileHeaders: java.util.List<net.lingala.zip4j.model.FileHeader>, fileName: string): java.util.List<net.lingala.zip4j.model.FileHeader>;
					public static getOffsetStartOfCentralDirectory(zipModel: net.lingala.zip4j.model.ZipModel): number;
					public static getFileHeader(zipModel: net.lingala.zip4j.model.ZipModel, fileName: string): net.lingala.zip4j.model.FileHeader;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module headers {
				export class HeaderWriter extends java.lang.Object {
					public static class: java.lang.Class<net.lingala.zip4j.headers.HeaderWriter>;
					public finalizeZipFileWithoutValidations(zipModel: net.lingala.zip4j.model.ZipModel, outputStream: java.io.OutputStream, charset: java.nio.charset.Charset): void;
					public constructor();
					public writeExtendedLocalHeader(localFileHeader: net.lingala.zip4j.model.LocalFileHeader, outputStream: java.io.OutputStream): void;
					public writeLocalFileHeader(zipModel: net.lingala.zip4j.model.ZipModel, localFileHeader: net.lingala.zip4j.model.LocalFileHeader, outputStream: java.io.OutputStream, charset: java.nio.charset.Charset): void;
					public finalizeZipFile(zipModel: net.lingala.zip4j.model.ZipModel, outputStream: java.io.OutputStream, charset: java.nio.charset.Charset): void;
					public updateLocalFileHeader(fileHeader: net.lingala.zip4j.model.FileHeader, zipModel: net.lingala.zip4j.model.ZipModel, outputStream: net.lingala.zip4j.io.outputstream.SplitOutputStream): void;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module headers {
				export class VersionMadeBy {
					public static class: java.lang.Class<net.lingala.zip4j.headers.VersionMadeBy>;
					public static SPECIFICATION_VERSION: net.lingala.zip4j.headers.VersionMadeBy;
					public static WINDOWS: net.lingala.zip4j.headers.VersionMadeBy;
					public static UNIX: net.lingala.zip4j.headers.VersionMadeBy;
					public static valueOf(name: string): net.lingala.zip4j.headers.VersionMadeBy;
					public static valueOf(enumType: java.lang.Class<any>, name: string): java.lang.Enum<any>;
					public static values(): net.lingala.zip4j.headers.VersionMadeBy[];
					public getCode(): number;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module headers {
				export class VersionNeededToExtract {
					public static class: java.lang.Class<net.lingala.zip4j.headers.VersionNeededToExtract>;
					public static DEFAULT: net.lingala.zip4j.headers.VersionNeededToExtract;
					public static DEFLATE_COMPRESSED: net.lingala.zip4j.headers.VersionNeededToExtract;
					public static ZIP_64_FORMAT: net.lingala.zip4j.headers.VersionNeededToExtract;
					public static AES_ENCRYPTED: net.lingala.zip4j.headers.VersionNeededToExtract;
					public static valueOf(enumType: java.lang.Class<any>, name: string): java.lang.Enum<any>;
					public static values(): net.lingala.zip4j.headers.VersionNeededToExtract[];
					public static valueOf(name: string): net.lingala.zip4j.headers.VersionNeededToExtract;
					public getCode(): number;
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class AesCipherInputStream extends net.lingala.zip4j.io.inputstream.CipherInputStream<net.lingala.zip4j.crypto.AESDecrypter> {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.AesCipherInputStream>;
						public initializeDecrypter(localFileHeader: net.lingala.zip4j.model.LocalFileHeader, password: string[], useUtf8ForPassword: boolean): net.lingala.zip4j.crypto.AESDecrypter;
						public read(): number;
						public constructor();
						public initializeDecrypter(param0: net.lingala.zip4j.model.LocalFileHeader, param1: string[], param2: boolean): any;
						public close(): void;
						public read(b: number[], off: number, len: number): number;
						public read(b: number[]): number;
						public constructor(zipEntryInputStream: net.lingala.zip4j.io.inputstream.ZipEntryInputStream, localFileHeader: net.lingala.zip4j.model.LocalFileHeader, password: string[], bufferSize: number, useUtf8ForPassword: boolean);
						public endOfEntryReached(inputStream: java.io.InputStream, numberOfBytesPushedBack: number): void;
						public readStoredMac(inputStream: java.io.InputStream): number[];
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export abstract class CipherInputStream<T>  extends java.io.InputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.CipherInputStream<any>>;
						public read(): number;
						public constructor();
						public close(): void;
						public getNumberOfBytesReadForThisEntry(): number;
						public getDecrypter(): any;
						public read(b: number[]): number;
						public constructor(zipEntryInputStream: net.lingala.zip4j.io.inputstream.ZipEntryInputStream, localFileHeader: net.lingala.zip4j.model.LocalFileHeader, password: string[], bufferSize: number, useUtf8ForPassword: boolean);
						public endOfEntryReached(inputStream: java.io.InputStream, numberOfBytesPushedBack: number): void;
						public readRaw(b: number[]): number;
						public initializeDecrypter(param0: net.lingala.zip4j.model.LocalFileHeader, param1: string[], param2: boolean): any;
						public read(b: number[], off: number, len: number): number;
						public getLocalFileHeader(): net.lingala.zip4j.model.LocalFileHeader;
						public getLastReadRawDataCache(): number[];
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export abstract class DecompressedInputStream extends java.io.InputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.DecompressedInputStream>;
						public oneByteBuffer: number[];
						public read(): number;
						public constructor();
						public pushBackInputStreamIfNecessary(pushbackInputStream: java.io.PushbackInputStream): number;
						public close(): void;
						public read(b: number[], off: number, len: number): number;
						public constructor(cipherInputStream: net.lingala.zip4j.io.inputstream.CipherInputStream<any>);
						public read(b: number[]): number;
						public endOfEntryReached(inputStream: java.io.InputStream, numberOfBytesPushedBack: number): void;
						public getLastReadRawDataCache(): number[];
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class InflaterInputStream extends net.lingala.zip4j.io.inputstream.DecompressedInputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.InflaterInputStream>;
						public constructor(cipherInputStream: net.lingala.zip4j.io.inputstream.CipherInputStream<any>, bufferSize: number);
						public read(): number;
						public constructor();
						public pushBackInputStreamIfNecessary(pushbackInputStream: java.io.PushbackInputStream): number;
						public close(): void;
						public read(b: number[], off: number, len: number): number;
						public constructor(cipherInputStream: net.lingala.zip4j.io.inputstream.CipherInputStream<any>);
						public read(b: number[]): number;
						public endOfEntryReached(inputStream: java.io.InputStream, numberOfBytesPushedBack: number): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class NoCipherInputStream extends net.lingala.zip4j.io.inputstream.CipherInputStream<net.lingala.zip4j.io.inputstream.NoCipherInputStream.NoDecrypter> {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.NoCipherInputStream>;
						public constructor();
						public initializeDecrypter(param0: net.lingala.zip4j.model.LocalFileHeader, param1: string[], param2: boolean): any;
						public close(): void;
						public initializeDecrypter(localFileHeader: net.lingala.zip4j.model.LocalFileHeader, password: string[], useUtf8ForPassword: boolean): net.lingala.zip4j.io.inputstream.NoCipherInputStream.NoDecrypter;
						public constructor(zipEntryInputStream: net.lingala.zip4j.io.inputstream.ZipEntryInputStream, localFileHeader: net.lingala.zip4j.model.LocalFileHeader, password: string[], bufferSize: number);
						public constructor(zipEntryInputStream: net.lingala.zip4j.io.inputstream.ZipEntryInputStream, localFileHeader: net.lingala.zip4j.model.LocalFileHeader, password: string[], bufferSize: number, useUtf8ForPassword: boolean);
					}
					export module NoCipherInputStream {
						export class NoDecrypter extends java.lang.Object implements net.lingala.zip4j.crypto.Decrypter {
							public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.NoCipherInputStream.NoDecrypter>;
							public decryptData(param0: number[], param1: number, param2: number): number;
							public decryptData(buff: number[], start: number, len: number): number;
						}
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class NumberedSplitFileInputStream extends net.lingala.zip4j.io.inputstream.SplitFileInputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.NumberedSplitFileInputStream>;
						public read(): number;
						public constructor();
						public prepareExtractionForFileHeader(param0: net.lingala.zip4j.model.FileHeader): void;
						public close(): void;
						public constructor(zipFile: java.io.File);
						public read(b: number[], off: number, len: number): number;
						public prepareExtractionForFileHeader(fileHeader: net.lingala.zip4j.model.FileHeader): void;
						public read(b: number[]): number;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class NumberedSplitRandomAccessFile extends java.io.RandomAccessFile {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.NumberedSplitRandomAccessFile>;
						public close(): void;
						public readUTF(): string;
						public openLastSplitFileForReading(): void;
						public writeChars(s: string): void;
						public readFully(param0: number[]): void;
						public readByte(): number;
						public write(b: number[]): void;
						public read(b: number[], off: number, len: number): number;
						public writeInt(param0: number): void;
						public writeUTF(str: string): void;
						public readLong(): number;
						public writeShort(param0: number): void;
						public writeChar(param0: number): void;
						public readFully(b: number[], off: number, len: number): void;
						public skipBytes(param0: number): number;
						public length(): number;
						public seekInCurrentPart(pos: number): void;
						public readFully(param0: number[], param1: number, param2: number): void;
						public skipBytes(n: number): number;
						public readDouble(): number;
						public write(b: number): void;
						public seek(pos: number): void;
						public read(b: number[]): number;
						public writeBoolean(v: boolean): void;
						public writeByte(v: number): void;
						public getFilePointer(): number;
						public writeBytes(param0: string): void;
						public constructor(name: string, mode: string);
						public write(param0: number[], param1: number, param2: number): void;
						public writeFloat(v: number): void;
						public writeBytes(s: string): void;
						public readInt(): number;
						public writeBoolean(param0: boolean): void;
						public readUnsignedByte(): number;
						public write(param0: number): void;
						public readChar(): string;
						public writeLong(v: number): void;
						public writeFloat(param0: number): void;
						public writeLong(param0: number): void;
						public readUnsignedShort(): number;
						public writeUTF(param0: string): void;
						public readFully(b: number[]): void;
						public write(b: number[], off: number, len: number): void;
						public writeShort(v: number): void;
						public writeChars(param0: string): void;
						public readLine(): string;
						public constructor(file: java.io.File, mode: string, allSortedSplitFiles: java.io.File[]);
						public read(): number;
						public constructor(file: java.io.File, mode: string);
						public writeDouble(param0: number): void;
						public writeInt(v: number): void;
						public readShort(): number;
						public writeDouble(v: number): void;
						public readBoolean(): boolean;
						public writeByte(param0: number): void;
						public write(param0: number[]): void;
						public writeChar(v: number): void;
						public seek(offset: number): void;
						public readFloat(): number;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export abstract class SplitFileInputStream extends java.io.InputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.SplitFileInputStream>;
						public constructor();
						public prepareExtractionForFileHeader(param0: net.lingala.zip4j.model.FileHeader): void;
						public close(): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class StoreInputStream extends net.lingala.zip4j.io.inputstream.DecompressedInputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.StoreInputStream>;
						public constructor();
						public close(): void;
						public constructor(cipherInputStream: net.lingala.zip4j.io.inputstream.CipherInputStream<any>);
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class ZipEntryInputStream extends java.io.InputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.ZipEntryInputStream>;
						public read(): number;
						public constructor();
						public close(): void;
						public read(b: number[], off: number, len: number): number;
						public read(b: number[]): number;
						public constructor(inputStream: java.io.InputStream, compressedSize: number);
						public getNumberOfBytesRead(): number;
						public readRawFully(b: number[]): number;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class ZipInputStream extends java.io.InputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.ZipInputStream>;
						public constructor(inputStream: java.io.InputStream, password: string[], zip4jConfig: net.lingala.zip4j.model.Zip4jConfig);
						public constructor(inputStream: java.io.InputStream, passwordCallback: net.lingala.zip4j.util.PasswordCallback);
						public constructor(inputStream: java.io.InputStream, password: string[], charset: java.nio.charset.Charset);
						public read(): number;
						public setPassword(password: string[]): void;
						public constructor();
						public getNextEntry(): net.lingala.zip4j.model.LocalFileHeader;
						public close(): void;
						public read(b: number[]): number;
						public available(): number;
						public constructor(inputStream: java.io.InputStream, password: string[]);
						public constructor(inputStream: java.io.InputStream, passwordCallback: net.lingala.zip4j.util.PasswordCallback, charset: java.nio.charset.Charset);
						public getNextEntry(fileHeader: net.lingala.zip4j.model.FileHeader, readUntilEndOfCurrentEntryIfOpen: boolean): net.lingala.zip4j.model.LocalFileHeader;
						public read(b: number[], off: number, len: number): number;
						public constructor(inputStream: java.io.InputStream, charset: java.nio.charset.Charset);
						public constructor(inputStream: java.io.InputStream, passwordCallback: net.lingala.zip4j.util.PasswordCallback, zip4jConfig: net.lingala.zip4j.model.Zip4jConfig);
						public constructor(inputStream: java.io.InputStream);
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class ZipStandardCipherInputStream extends net.lingala.zip4j.io.inputstream.CipherInputStream<net.lingala.zip4j.crypto.StandardDecrypter> {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.ZipStandardCipherInputStream>;
						public constructor();
						public initializeDecrypter(param0: net.lingala.zip4j.model.LocalFileHeader, param1: string[], param2: boolean): any;
						public close(): void;
						public initializeDecrypter(localFileHeader: net.lingala.zip4j.model.LocalFileHeader, password: string[], useUtf8ForPassword: boolean): net.lingala.zip4j.crypto.StandardDecrypter;
						public constructor(zipEntryInputStream: net.lingala.zip4j.io.inputstream.ZipEntryInputStream, localFileHeader: net.lingala.zip4j.model.LocalFileHeader, password: string[], bufferSize: number, useUtf8ForPassword: boolean);
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module inputstream {
					export class ZipStandardSplitFileInputStream extends net.lingala.zip4j.io.inputstream.SplitFileInputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.inputstream.ZipStandardSplitFileInputStream>;
						public randomAccessFile: java.io.RandomAccessFile;
						public zipFile: java.io.File;
						public read(): number;
						public constructor();
						public prepareExtractionForFileHeader(param0: net.lingala.zip4j.model.FileHeader): void;
						public close(): void;
						public read(b: number[], off: number, len: number): number;
						public getNextSplitFile(zipFileIndex: number): java.io.File;
						public prepareExtractionForFileHeader(fileHeader: net.lingala.zip4j.model.FileHeader): void;
						public constructor(zipFile: java.io.File, isSplitZipArchive: boolean, lastSplitZipFileNumber: number);
						public read(b: number[]): number;
						public openRandomAccessFileForIndex(zipFileIndex: number): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module outputstream {
					export class AesCipherOutputStream extends net.lingala.zip4j.io.outputstream.CipherOutputStream<net.lingala.zip4j.crypto.AESEncrypter> {
						public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.AesCipherOutputStream>;
						public constructor(outputStream: net.lingala.zip4j.io.outputstream.ZipEntryOutputStream, zipParameters: net.lingala.zip4j.model.ZipParameters, password: string[], useUtf8ForPassword: boolean);
						public initializeEncrypter(param0: java.io.OutputStream, param1: net.lingala.zip4j.model.ZipParameters, param2: string[], param3: boolean): any;
						public write(b: number[]): void;
						public constructor();
						public constructor(zipEntryOutputStream: net.lingala.zip4j.io.outputstream.ZipEntryOutputStream, zipParameters: net.lingala.zip4j.model.ZipParameters, password: string[], useUtf8ForPassword: boolean);
						public close(): void;
						public initializeEncrypter(outputStream: java.io.OutputStream, zipParameters: net.lingala.zip4j.model.ZipParameters, password: string[], useUtf8ForPassword: boolean): net.lingala.zip4j.crypto.AESEncrypter;
						public write(b: number): void;
						public flush(): void;
						public closeEntry(): void;
						public write(b: number[], off: number, len: number): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module outputstream {
					export abstract class CipherOutputStream<T>  extends java.io.OutputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.CipherOutputStream<any>>;
						public initializeEncrypter(param0: java.io.OutputStream, param1: net.lingala.zip4j.model.ZipParameters, param2: string[], param3: boolean): any;
						public constructor();
						public writeHeaders(b: number[]): void;
						public close(): void;
						public write(param0: number): void;
						public write(b: number): void;
						public flush(): void;
						public closeEntry(): void;
						public getNumberOfBytesWrittenForThisEntry(): number;
						public getEncrypter(): any;
						public write(b: number[]): void;
						public constructor(zipEntryOutputStream: net.lingala.zip4j.io.outputstream.ZipEntryOutputStream, zipParameters: net.lingala.zip4j.model.ZipParameters, password: string[], useUtf8ForPassword: boolean);
						public write(b: number[], off: number, len: number): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module outputstream {
					export abstract class CompressedOutputStream extends java.io.OutputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.CompressedOutputStream>;
						public write(b: number[]): void;
						public constructor();
						public getCompressedSize(): number;
						public constructor(cipherOutputStream: net.lingala.zip4j.io.outputstream.CipherOutputStream<any>);
						public close(): void;
						public write(param0: number): void;
						public write(b: number): void;
						public flush(): void;
						public closeEntry(): void;
						public write(b: number[], off: number, len: number): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module outputstream {
					export class CountingOutputStream extends java.io.OutputStream implements net.lingala.zip4j.io.outputstream.OutputStreamWithSplitZipSupport {
						public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.CountingOutputStream>;
						public constructor();
						public close(): void;
						public constructor(outputStream: java.io.OutputStream);
						public write(param0: number): void;
						public write(b: number): void;
						public flush(): void;
						public getCurrentSplitFileCounter(): number;
						public checkBuffSizeAndStartNextSplitFile(bufferSize: number): boolean;
						public getSplitLength(): number;
						public getFilePointer(): number;
						public write(b: number[]): void;
						public getNumberOfBytesWritten(): number;
						public isSplitZipFile(): boolean;
						public getOffsetForNextEntry(): number;
						public write(b: number[], off: number, len: number): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module outputstream {
					export class DeflaterOutputStream extends net.lingala.zip4j.io.outputstream.CompressedOutputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.DeflaterOutputStream>;
						public deflater: java.util.zip.Deflater;
						public write(b: number[]): void;
						public constructor();
						public constructor(cipherOutputStream: net.lingala.zip4j.io.outputstream.CipherOutputStream<any>);
						public close(): void;
						public write(b: number): void;
						public flush(): void;
						public closeEntry(): void;
						public write(buf: number[], off: number, len: number): void;
						public write(b: number[], off: number, len: number): void;
						public write(bval: number): void;
						public constructor(cipherOutputStream: net.lingala.zip4j.io.outputstream.CipherOutputStream<any>, compressionLevel: net.lingala.zip4j.model.enums.CompressionLevel, bufferSize: number);
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module outputstream {
					export class NoCipherOutputStream extends net.lingala.zip4j.io.outputstream.CipherOutputStream<net.lingala.zip4j.io.outputstream.NoCipherOutputStream.NoEncrypter> {
						public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.NoCipherOutputStream>;
						public initializeEncrypter(param0: java.io.OutputStream, param1: net.lingala.zip4j.model.ZipParameters, param2: string[], param3: boolean): any;
						public initializeEncrypter(outputStream: java.io.OutputStream, zipParameters: net.lingala.zip4j.model.ZipParameters, password: string[], useUtf8ForPassword: boolean): net.lingala.zip4j.io.outputstream.NoCipherOutputStream.NoEncrypter;
						public constructor();
						public constructor(zipEntryOutputStream: net.lingala.zip4j.io.outputstream.ZipEntryOutputStream, zipParameters: net.lingala.zip4j.model.ZipParameters, password: string[]);
						public constructor(zipEntryOutputStream: net.lingala.zip4j.io.outputstream.ZipEntryOutputStream, zipParameters: net.lingala.zip4j.model.ZipParameters, password: string[], useUtf8ForPassword: boolean);
						public close(): void;
						public flush(): void;
					}
					export module NoCipherOutputStream {
						export class NoEncrypter extends java.lang.Object implements net.lingala.zip4j.crypto.Encrypter {
							public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.NoCipherOutputStream.NoEncrypter>;
							public encryptData(buff: number[]): number;
							public encryptData(param0: number[]): number;
							public encryptData(param0: number[], param1: number, param2: number): number;
							public encryptData(buff: number[], start: number, len: number): number;
						}
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module outputstream {
					export class OutputStreamWithSplitZipSupport extends java.lang.Object {
						public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.OutputStreamWithSplitZipSupport>;
						/**
						 * Constructs a new instance of the net.lingala.zip4j.io.outputstream.OutputStreamWithSplitZipSupport interface with the provided implementation. An empty constructor exists calling super() when extending the interface class.
						 */
						public constructor(implementation: {
							getFilePointer(): number;
							getCurrentSplitFileCounter(): number;
						});
						public constructor();
						public getCurrentSplitFileCounter(): number;
						public getFilePointer(): number;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module outputstream {
					export class SplitOutputStream extends java.io.OutputStream implements net.lingala.zip4j.io.outputstream.OutputStreamWithSplitZipSupport {
						public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.SplitOutputStream>;
						public constructor();
						public close(): void;
						public write(param0: number): void;
						public skipBytes(n: number): number;
						public write(b: number): void;
						public seek(pos: number): void;
						public flush(): void;
						public getCurrentSplitFileCounter(): number;
						public getSplitLength(): number;
						public getFilePointer(): number;
						public write(b: number[]): void;
						public isSplitZipFile(): boolean;
						public constructor(file: java.io.File);
						public write(b: number[], off: number, len: number): void;
						public constructor(file: java.io.File, splitLength: number);
						public checkBufferSizeAndStartNextSplitFile(bufferSize: number): boolean;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export module io {
				export module outputstream {
					export class StoreOutputStream extends net.lingala.zip4j.io.outputstream.CompressedOutputStream {
						public static class: java.lang.Class<net.lingala.zip4j.io.outputstream.StoreOutputStream>;
						public constructor();
						public constructor(cipherOutputStream: net.lingala.zip4j.io.outputstream.CipherOutputStream<any>);
						public close(): void;
						public flush(): void;
					}
				}
			}
		}
	}
}

declare module net {
	export module lingala {
		export module zip4j {
			export modul