$$.cd(dir: string): ProcessPromise

await $$.pwd(); // '/Users/username'
await $$.cd('./some/folder');
await $$.pwd(); // '/Users/username/some/folder'

$$.pwd(): Promise<string>

await $$.pwd(); // '/Users/username'
await $$.cd('./some/folder');
await $$.pwd(); // '/Users/username/some/folder'

$$.ls(dir: string, flags: string[]): Promise<string[]>

await $$.ls('example') // ['a', 'b']

$$.rm(item: string): ProcessPromise

await $$.rm('example') // same as $`rm -rf 'example'`

$$.mkdir(item: string): ProcessPromise

await $$.mkdir('example') // same as $`mkdir -p 'example'`

$$.cp(a: string, b: string): ProcessPromise

await $$.cp('example1', 'example2') // same as $`cp -r 'example1' 'example2'`

$$.mv(a: string, b: string): ProcessPromise

await $$.mv('example1', 'example2') // same as $`mv 'example1' 'example2'`

$$.touch(item: string): ProcessPromise

await $$.touch('example') // same as $`touch 'example'`

$$.cat(item: string): ProcessPromise

await $$.cat('example') // same as $`cat 'example'`

$$.grep(pattern: string, file: string): Promise<string[]>

await $$.grep('example', '.') // same as $`grep 'example' '.'`

$$.find(dir: string, options: FindOptions): Promise<string[]>

await $$.find('.', { type: 'f' }) // ['a', 'b']

$$.FindOptions;

$$.FindType;

$$.findDirs(dir: string, options: FindOptions): Promise<string[]>

await $$.findDirs('.') // ['a', 'b']

$$.findFiles(dir: string, options: FindOptions): Promise<string[]>

await $$.findFiles('.') // ['a', 'b']

$$.findModified(dir: string, options: FindOptions): Promise<ModifiedFile[]>

await $$.findModified('.')
// [
//   {
//     lastModified: 1689206400000,
//     path: './a.mp4',
//     dir: '.',
//     folders: ['.'],
//     name: 'a',
//     ext: 'mp4',
//     filename: 'a.mp4'
//   }
// ]

$$.ModifiedFile;

{
  lastModified: 1689206400000,
  path: './a.mp4',
  dir: '.',
  folders: ['.'],
  name: 'a',
  ext: 'mp4',
  filename: 'a.mp4'
}

$$.lastModified(path: string): Promise<number>

await $$.lastModified('a.mp4') // 1689206400000

$$.rsync(a: string, b: string, flags: string[], progressBarOpts: Partial<progressBar.ProgressBarOptions>): Promise<any>

await $$.rsync('example1', 'example2') // same as $`rsync -rut 'example1' 'example2'`

$$.sync(a: string, b: string, progressBarOpts: Partial<progressBar.ProgressBarOptions>): Promise<any>

await $$.sync('example1', 'example2') // same as $`rsync -rut 'example1' 'example2' --delete`

$$.isFileExist(file: string): Promise<boolean>

await $$.isFileExist('example') // true

$$.isDirExist(dir: string): Promise<boolean>

await $$.isDirExist('example') // true

$$.readFile(filepath: string): Promise<string>

await $$.readFile('example') // 'hello world'

$$.writeFile(filepath: string, contents: string): Promise<void>

await $$.writeFile('example', 'hello world') // saves a new file called 'example' with the contents 'hello world'

$$.readJSON<T>(filepath: string): Promise<T>

await $$.readJSON('example.json') // { hello: 'world' }

$$.writeJSON<T>(obj: T): Promise<T>

await $$.writeJSON('example.json', { hello: 'world' }) // saves a new file called 'example.json' with the contents {'hello':'world'}

$$.pipe(processes: ((index?: number, arg?: T) => ProcessPromise)[], arg: T): ProcessPromise

await $$.pipe([
  () => gm.convert(basePath, gm.PIPE, opts1),
  () => gm.composite(changePath, gm.PIPE, gm.PIPE, changePath, opts2)
]);

$$.exiftool(file: string, setAttr: ExifToolAttributesObj, getAttr: (ExifToolAttributes | string)[], outFile: string): Promise<ExifToolAttributesObj>

$$.exiftool('/path/to/file.jpg', {'Copyright': 'Eg val'});
$$.exiftool('/path/to/file.jpg', {'Copyright': 'Eg val'}, undefined, '/path/to/new_file.jpg');

$$.ExifToolAttributesObj;

$$.ExifToolAttributes;

$$.utils.intoLines(out: ProcessOutput): string[]

utils.intoLines($`echo "1\n2\n3"`) // ['1', '2', '3']

closeFinder(): Promise<void>
os.closeFinder(): Promise<void>

await closeFinder();

ffmpeg(command: () => ProcessPromise, progressFileName: string, totalFrames: number, progressBarOpts: progressBar.ProgressBarOptions): Promise<void>
ffmpegTools.ffmpeg(command: () => ProcessPromise, progressFileName: string, totalFrames: number, progressBarOpts: progressBar.ProgressBarOptions): Promise<void>

const progBarOpts = {}; // Same options as getProgressBar
await ffmpeg(() => $`ffmpeg -y -i ${a} ${b} -progress ${pr}`, pr, framesNum, progBarOpts);

ffmpegTools.toFFmpegTimeFormat(time: ms): string

ffmpegTools.toFFmpegTimeFormat(minutes(3)); // '03:00.000'
ffmpegTools.toFFmpegTimeFormat(minutes(3) + seconds(21)); // '03:21.000'
ffmpegTools.toFFmpegTimeFormat(minutes(3) + seconds(21) + 456); // '03:21.456'

ffmpegTools.getProbe(file: string): Promise<ProbeResult>

const probe = await getProbe('file.mp4'); // { width: 1280, height: 720, ... }

ffmpegTools.ProbeResult;

ffmpegTools.getProbeValue(file: string, propertyName: string): Promise<string>

const probe = await getProbe('file.mp4', 'width'); // '1280'

ffmpegTools.getTotalFrames(list: string | string[]): Promise<number>

const num = await getTotalFrames('video.mp4'); // 120 (2 secs at 60fps)

gm.convert(inPath: string, outPath: string, flags: ConvertFlagsObj): ProcessPromise

const converted = await gm.convert(input, output, {});

gm.ConvertFlagsObj;

gm.composite(changePath: string, basePath: string, outPath: string, maskPath: string, flags: ChangeAndMaskFlags | CompositeFlagsObj): ProcessPromise

const composited = await gm.composite(change, base, out, undefined, {});

gm.CompositeFlagsObj;

gm.ChangeAndMaskFlags;

{
  change?: CompositeFlagsObj;
  mask?: CompositeFlagsObj;
}

gm.pipe(inPath: string, outPath: string, processes: ((pipeIn?: string, pipeOut?: string, index?: number) => ProcessPromise)[]): ProcessPromise

await pipe(basePath, outPath, [
  (p) => convert(p, p, opts1),
  (p) => composite(changePath, p, p, changePath, opts2)
]);
await pipe(undefined, undefined, [
  (p) => convert(basePath, p, opts1),
  (p) => composite(changePath, p, outPath, changePath, opts2)
]);

gm.PIPE;

gm.CommonFlagsObj;

gm.FlagsObj;

gm.channel;

gm.utils.flagsObjToArray(obj: gm.FlagsObj): (string | number)[]

gm.utils.flagsObjToArray({ channel: 'red' }); // [ '-channel', 'red' ]
gm.utils.flagsObjToArray({ displace: '10' }); // [ '-displace', '10' ]

gm.utils.flagsObjToArray({ resize: '1080', fill: 'gray', gravity: 'SouthEast' });
// ['-resize', '1080', '-fill', 'gray', '-gravity', 'SouthEast']

gm.utils.flagsObjToArray({ brightness: 150, saturation: 50, hue: 200 });
// [ '-modulate', '150,50,200' ]

gm.utils.channelComposeCopyMap;

gm.utils.channelComposeCopyMap['red'] // 'CopyRed'
gm.utils.channelComposeCopyMap['magena'] // 'CopyMagenta'
gm.utils.channelComposeCopyMap['gray'] // 'Copy'

gm.utils.supportedFlags;

gm.utils.GMCommand;

'convert' | 'composite'

gm.utils.SupportedFlag;