@baadal-sdk/dapi 0.31.6 → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,674 @@
+/**
+ * Check whether a file exists
+ * @param file file path
+ * @param loud whether to throw errors [default: false]
+ * @returns true if it exists, false if it doesn't, null in case of error
+ */
+declare const existsFileSync: (file: string, loud?: boolean) => boolean | null;
+/**
+ * Check whether a directory exists
+ * @param dir directory path
+ * @param loud whether to throw errors [default: false]
+ * @returns true if it exists, false if it doesn't, null in case of error
+ */
+declare const existsDirSync: (dir: string, loud?: boolean) => boolean | null;
+/**
+ * Read contents of a file
+ * @param file file path
+ * @param warn whether to show warnings [default: false]
+ * @returns contents of the file, null in case of error
+ */
+declare const readFile: (file: string, warn?: boolean) => Promise<string | null>;
+/**
+ * Read contents of a file
+ * @param file file path
+ * @param warn whether to show warnings [default: false]
+ * @returns contents of the file, null in case of error
+ */
+declare const readFileSync: (file: string, warn?: boolean) => string | null;
+/**
+ * Get the list of files/directories in a directory
+ * @param dir directory path
+ * @param warn whether to show warnings [default: false]
+ * @param hiddenItems whether to include items starting with dot(.) [default: false]
+ * @returns an object {dirs,files} containing list of directories & files, null in case or error
+ */
+declare const readDir: (dir: string, warn?: boolean, hiddenItems?: boolean) => Promise<{
+    dirs: string[];
+    files: string[];
+} | null>;
+/**
+ * Get the list of files in a directory
+ * @param dir directory path
+ * @param warn whether to show warnings [default: false]
+ * @param hiddenItems whether to include items starting with dot(.) [default: false]
+ * @returns list of files, null in case of error
+ */
+declare const readDirFiles: (dir: string, warn?: boolean, hiddenItems?: boolean) => Promise<string[] | null>;
+/**
+ * Get the list of directories in a directory
+ * @param dir directory path
+ * @param warn whether to show warnings [default: false]
+ * @param hiddenItems whether to include items starting with dot(.) [default: false]
+ * @returns list of directories, null in case of error
+ */
+declare const readDirDirs: (dir: string, warn?: boolean, hiddenItems?: boolean) => Promise<string[] | null>;
+/**
+ * Get the (recursive) list of files in a directory
+ * @param dir directory path
+ * @param hiddenItems whether to include items starting with dot(.) [default: false]
+ * @returns complete (recursive) list of files, null in case of error
+ */
+declare const readDirFilesRec: (dir: string, hiddenItems?: boolean) => Promise<string[] | null>;
+/**
+ * Write contents to a file (creates the file path if it doesn't exist)
+ * @param file file path
+ * @param contents contents to write
+ * @returns true if successful, null in case of error
+ */
+declare const writeFile: (file: string, contents: string) => Promise<true | null>;
+/**
+ * Append contents to a file
+ * @param file file path
+ * @param contents contents to append
+ * @returns true if successful, null in case of error
+ */
+declare const appendToFile: (file: string, contents: string) => Promise<true | null>;
+/**
+ * Rename a file
+ * @param oldpath old file path
+ * @param newpath new file path
+ * @returns true if successful, null in case of error
+ */
+declare const renameFile: (oldpath: string, newpath: string) => Promise<true | null>;
+/**
+ * Create a directory, if it doesn't exist
+ * @param dir directory path
+ * @returns true if successful, null in case of failure/error
+ */
+declare const createDir: (dir: string) => Promise<true | null>;
+/**
+ * Delete a file
+ * @param file file path
+ * @returns true if successful, null in case of error
+ */
+declare const deleteFile: (file: string) => Promise<true | null>;
+/**
+ * Delete a directory
+ * @param dir directory path
+ * @returns true if successful, null in case of error
+ */
+declare const deleteDir: (dir: string) => Promise<true | null>;
+
+declare const fs_appendToFile: typeof appendToFile;
+declare const fs_createDir: typeof createDir;
+declare const fs_deleteDir: typeof deleteDir;
+declare const fs_deleteFile: typeof deleteFile;
+declare const fs_existsDirSync: typeof existsDirSync;
+declare const fs_existsFileSync: typeof existsFileSync;
+declare const fs_readDir: typeof readDir;
+declare const fs_readDirDirs: typeof readDirDirs;
+declare const fs_readDirFiles: typeof readDirFiles;
+declare const fs_readDirFilesRec: typeof readDirFilesRec;
+declare const fs_readFile: typeof readFile;
+declare const fs_readFileSync: typeof readFileSync;
+declare const fs_renameFile: typeof renameFile;
+declare const fs_writeFile: typeof writeFile;
+declare namespace fs {
+  export { fs_appendToFile as appendToFile, fs_createDir as createDir, fs_deleteDir as deleteDir, fs_deleteFile as deleteFile, fs_existsDirSync as existsDirSync, fs_existsFileSync as existsFileSync, fs_readDir as readDir, fs_readDirDirs as readDirDirs, fs_readDirFiles as readDirFiles, fs_readDirFilesRec as readDirFilesRec, fs_readFile as readFile, fs_readFileSync as readFileSync, fs_renameFile as renameFile, fs_writeFile as writeFile };
+}
+
+interface StringIndexable<T = any> {
+    [key: string]: T;
+}
+
+/**
+ * Examples:
+ * Ref: https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/dynamodb-examples.html
+ *
+ * Partition key vs Composite primary key:
+ * Ref: https://aws.amazon.com/premiumsupport/knowledge-center/primary-key-dynamodb-table/
+ */
+
+/** @internal */
+declare const init$2: (_region?: string) => Promise<boolean>;
+/** @internal */
+declare const status$2: () => string | null;
+interface WriteItemForceInput<T = any> {
+    table: string;
+    item: T;
+    key?: string;
+}
+type WriteItemUniqueInput<T = any> = WriteItemForceInput<T>;
+/**
+ * Write an item to a DynamoDB table, retry in case of key conflict
+ * @param input input command object
+ * @returns the created item, null in case of error
+ *
+ * ```js
+ * writeItemForce({
+ *   table: 'lesson_list',
+ *   item: { title: 'My Lesson' },
+ *   key: 'id',
+ * });
+ *
+ * interface WriteItemForceInput<T = any> {
+ *   table: string;
+ *   item: T;
+ *   key?: string; // default: `id`
+ * }
+ * ```
+ */
+declare const writeItemForce: <T = any>(input: WriteItemForceInput<T>) => Promise<T | null>;
+/**
+ * Write an item (uniquely) to a DynamoDB table.
+ * Unlike `writeItemForce`, it does not retry in case of key conflict
+ * Unlike `writeItem`, it does not overwrite an item with the same key (if it exists)
+ * @param input input command object
+ * @returns the created item, null in case of error or key conflict (i.e., if item with same key already exists)
+ *
+ * ```js
+ * writeItemUnique({
+ *   table: 'lesson_list',
+ *   item: { id: 'id_001', title: 'My Lesson' },
+ *   key: 'id',
+ * });
+ *
+ * interface WriteItemUniqueInput<T = any> {
+ *   table: string;
+ *   item: T;
+ *   key?: string; // default: `id`
+ * }
+ * ```
+ */
+declare const writeItemUnique: <T = any>(input: WriteItemUniqueInput<T>) => Promise<T | null>;
+interface WriteItemInput {
+    table: string;
+    item: StringIndexable;
+}
+/**
+ * Write an item to a DynamoDB table
+ * @param input input command object
+ * @returns true if successful, null in case of error
+ *
+ * ```js
+ * writeItem({
+ *   table: 'lesson_list',
+ *   item: { id: 'id_001', title: 'My Lesson' },
+ * });
+ *
+ * interface WriteItemInput {
+ *   table: string;
+ *   item: StringIndexable;
+ * }
+ * ```
+ */
+declare const writeItem: (input: WriteItemInput) => Promise<true | null>;
+interface WriteItemsAllInput {
+    table: string;
+    items: StringIndexable[];
+}
+/**
+ * Write a list of items to a DynamoDB table
+ * @param input input command object
+ * @returns true if successful, null in case of error
+ *
+ * ```js
+ * writeItemsAll({
+ *   table: 'lesson_list',
+ *   items: [{ id: 'id_001', title: 'My Lesson' }, { id: 'id_002', title: 'My Lesson 2' }],
+ * });
+ *
+ * interface WriteItemInput {
+ *   table: string;
+ *   items: StringIndexable[];
+ * }
+ * ```
+ */
+declare const writeItemsAll: (input: WriteItemsAllInput) => Promise<true | null>;
+interface UpdateItemInput {
+    table: string;
+    key: StringIndexable;
+    update: string;
+    attr: StringIndexable;
+    attrNames?: StringIndexable;
+}
+/**
+ * Update an item in DynamoDB table
+ * @param input input command object
+ * @returns true if successful, null in case of error
+ *
+ * ```js
+ * updateItem({
+ *   table: 'lesson_list',
+ *   key: { id: 'id_001' },
+ *   update: 'SET status = :status, #rev = 10',
+ *   attr: { ':status': 'completed' },
+ *   attrNames: { '#rev': 'revision' },
+ * });
+ *
+ * interface UpdateItemInput {
+ *   table: string;
+ *   key: StringIndexable;
+ *   update: string;
+ *   attr: StringIndexable;
+ *   attrNames?: StringIndexable;
+ * }
+ * ```
+ */
+declare const updateItem: (input: UpdateItemInput) => Promise<true | null>;
+interface ReadItemInput {
+    table: string;
+    key: StringIndexable;
+    projection?: string;
+    attrNames?: StringIndexable;
+    loud?: boolean;
+}
+/**
+ * Read an item from DynamoDB table
+ * @param input input command object
+ * @returns item contents, null in case of error
+ *
+ * ```js
+ * readItem({
+ *   table: 'lesson_list',
+ *   key: { id: 'id_001' },
+ *   projection: 'id, lesson, status',
+ * });
+ *
+ * interface ReadItemInput {
+ *   table: string;
+ *   key: StringIndexable;
+ *   projection?: string;
+ *   attrNames?: StringIndexable;
+ * }
+ * ```
+ */
+declare const readItem: <T = any>(input: ReadItemInput) => Promise<T | null>;
+interface ReadItemsAllInput {
+    table: string;
+    keys: StringIndexable[];
+    projection?: string;
+    attrNames?: StringIndexable;
+}
+/**
+ * Read a list of items from DynamoDB table
+ * Note: ordering of items in result may not be same as that in `keys`
+ * @param input input command object
+ * @returns list of contents for items, null in case of error
+ *
+ * ```js
+ * readItemsAll({
+ *   table: 'lesson_list',
+ *   keys: [{ id: 'id_001' }, { id: 'id_002' }],
+ *   projection: 'id, lesson, status',
+ * });
+ *
+ * interface ReadItemsAllInput {
+ *   table: string;
+ *   keys: StringIndexable[];
+ *   projection?: string;
+ *   attrNames?: StringIndexable;
+ * }
+ * ```
+ */
+declare const readItemsAll: <T = any>(input: ReadItemsAllInput) => Promise<StringIndexable<T>[] | null>;
+interface QueryItemsInput {
+    table: string;
+    indexName?: string;
+    cond: string;
+    attr: StringIndexable;
+    attrNames?: StringIndexable;
+    projection?: string;
+    desc?: boolean;
+}
+/**
+ * Query items from a DynamoDB table based on some condition
+ * @param input input command object
+ * @returns query results array, null in case of error
+ *
+ * ```js
+ * dbQueryItems({
+ *   table: 'lesson_list',
+ *   indexName: 'status-revision-index',
+ *   cond: 'status = :comp AND #rev >= :rev',
+ *   attr: { ':comp': 'completed', ':rev': 9 },
+ *   attrNames: { '#rev': 'revision' },
+ *   projection: 'id, lesson, status, revision',
+ * });
+ *
+ * interface QueryItemsInput {
+ *   table: string;
+ *   indexName?: string;
+ *   cond: string;
+ *   attr: StringIndexable;
+ *   attrNames?: StringIndexable;
+ *   projection?: string;
+ *   desc?: boolean;
+ * }
+ * ```
+ */
+declare const queryItems: (input: QueryItemsInput) => Promise<StringIndexable<any>[] | null>;
+interface ScanItemsInput {
+    table: string;
+    projection?: string;
+}
+/**
+ * Scan all items in a DynamoDB table
+ * Note: avoid using this method in favour of `queryItems` method due to performance reasons
+ * @param input input command object
+ * @returns results of the scan query, null in case of error
+ *
+ * ```js
+ * scanItems({
+ *   table: 'lesson_list',
+ *   projection: 'id, status',
+ * });
+ *
+ * interface ScanItemsInput {
+ *   table: string;
+ *   projection?: string;
+ * }
+ * ```
+ */
+declare const scanItems: (input: ScanItemsInput) => Promise<StringIndexable<any>[] | null>;
+interface DeleteItemInput {
+    table: string;
+    key: StringIndexable;
+}
+/**
+ * Delete an item in a DynamoDB table
+ * @param input input command object
+ * @returns true if successful, null in case of error
+ *
+ * ```js
+ * deleteItem({
+ *   table: 'lesson_list',
+ *   key: { id: 'id_001' },
+ * });
+ *
+ * interface DeleteItemInput {
+ *   table: string;
+ *   key: StringIndexable;
+ * }
+ * ```
+ */
+declare const deleteItem: (input: DeleteItemInput) => Promise<true | null>;
+interface DeleteItemsAllInput {
+    table: string;
+    keys: StringIndexable[];
+}
+/**
+ * Delete a list of items in a DynamoDB table
+ * @param input input command object
+ * @returns true if successful, null in case of error
+ *
+ * ```js
+ * deleteItemsAll({
+ *   table: 'lesson_list',
+ *   keys: [{ id: 'id_001' }, { id: 'id_002' }],
+ * });
+ *
+ * interface DeleteItemsAllInput {
+ *   table: string;
+ *   keys: StringIndexable[];
+ * }
+ * ```
+ */
+declare const deleteItemsAll: (input: DeleteItemsAllInput) => Promise<true | null>;
+
+type db_DeleteItemInput = DeleteItemInput;
+type db_DeleteItemsAllInput = DeleteItemsAllInput;
+type db_QueryItemsInput = QueryItemsInput;
+type db_ReadItemInput = ReadItemInput;
+type db_ReadItemsAllInput = ReadItemsAllInput;
+type db_ScanItemsInput = ScanItemsInput;
+type db_UpdateItemInput = UpdateItemInput;
+type db_WriteItemForceInput<T = any> = WriteItemForceInput<T>;
+type db_WriteItemInput = WriteItemInput;
+type db_WriteItemUniqueInput<T = any> = WriteItemUniqueInput<T>;
+type db_WriteItemsAllInput = WriteItemsAllInput;
+declare const db_deleteItem: typeof deleteItem;
+declare const db_deleteItemsAll: typeof deleteItemsAll;
+declare const db_queryItems: typeof queryItems;
+declare const db_readItem: typeof readItem;
+declare const db_readItemsAll: typeof readItemsAll;
+declare const db_scanItems: typeof scanItems;
+declare const db_updateItem: typeof updateItem;
+declare const db_writeItem: typeof writeItem;
+declare const db_writeItemForce: typeof writeItemForce;
+declare const db_writeItemUnique: typeof writeItemUnique;
+declare const db_writeItemsAll: typeof writeItemsAll;
+declare namespace db {
+  export { type db_DeleteItemInput as DeleteItemInput, type db_DeleteItemsAllInput as DeleteItemsAllInput, type db_QueryItemsInput as QueryItemsInput, type db_ReadItemInput as ReadItemInput, type db_ReadItemsAllInput as ReadItemsAllInput, type db_ScanItemsInput as ScanItemsInput, type db_UpdateItemInput as UpdateItemInput, type db_WriteItemForceInput as WriteItemForceInput, type db_WriteItemInput as WriteItemInput, type db_WriteItemUniqueInput as WriteItemUniqueInput, type db_WriteItemsAllInput as WriteItemsAllInput, db_deleteItem as deleteItem, db_deleteItemsAll as deleteItemsAll, init$2 as init, db_queryItems as queryItems, db_readItem as readItem, db_readItemsAll as readItemsAll, db_scanItems as scanItems, status$2 as status, db_updateItem as updateItem, db_writeItem as writeItem, db_writeItemForce as writeItemForce, db_writeItemUnique as writeItemUnique, db_writeItemsAll as writeItemsAll };
+}
+
+/**
+ * Examples:
+ * Ref: https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/s3-examples.html
+ */
+
+/** @internal */
+declare const init$1: (_region?: string) => Promise<boolean>;
+/** @internal */
+declare const status$1: () => string | null;
+/**
+ * Create a new file in S3 bucket
+ * @param bucket S3 bucket name
+ * @param s3path S3 path to be created
+ * @param contents contents of the file to be created
+ * @returns true if the write is successful, null in case of error
+ */
+declare const putObject: (bucket: string, s3path: string, contents: string) => Promise<true | null>;
+/**
+ * Upload a file to S3 bucket
+ * @param bucket S3 bucket name
+ * @param file (local) path of the file to upload
+ * @param s3path [optional] S3 path to be created, if not provided then derived from `file` path
+ * @returns true if the write is successful, null in case of error
+ */
+declare const uploadFile: (bucket: string, file: string, s3path?: string) => Promise<true | null>;
+/**
+ * Upload a list of files to S3 bucket
+ * @param bucket S3 bucket name
+ * @param files (local) list of file paths to upload
+ * @param s3paths [optional] S3 path to be created, if not provided then derived from `file` path
+ * @returns true if all uploads are successful, null in case of error
+ */
+declare const uploadFilesAll: (bucket: string, files: string[], s3paths?: string[]) => Promise<true | null>;
+/**
+ * Get the contents of a file in S3 bucket
+ * @param bucket S3 bucket name
+ * @param s3path S3 path of the file to be read
+ * @returns contents of the file, null in case of error
+ */
+declare const getObject: (bucket: string, s3path: string) => Promise<string | null>;
+/**
+ * Download a file from S3 bucket
+ * @param bucket S3 bucket name
+ * @param s3path S3 path of the file to be downloaded
+ * @param outPath [optional] path where the downloaded file is written, if not provided then derived from `s3path`
+ * @returns true if download is successful, null in case of error
+ */
+declare const downloadFile: (bucket: string, s3path: string, outPath?: string) => Promise<true | null>;
+/**
+ * List objects in a S3 bucket
+ * @param bucket S3 bucket name
+ * @param prefix [optional] prefix for object names in the bucket
+ * @returns list of objects in the S3 bucket (optionally starting with the given prefix), null in case of error
+ */
+declare const listObjects: (bucket: string, prefix?: string) => Promise<string[] | null>;
+/**
+ * Get head content for a file in S3 bucket
+ * @param bucket S3 bucket name
+ * @param s3path S3 path of the file
+ * @returns head content for the given file, null in case of error
+ */
+declare const getObjectHead: (bucket: string, s3path: string) => Promise<HeadObject | null>;
+/**
+ * Get head contents for a list of files in S3 bucket
+ * @param bucket S3 bucket name
+ * @param s3paths list of S3 paths of the files
+ * @returns head contents for the given files, null in case of error
+ */
+declare const getObjectHeadsAll: (bucket: string, s3paths: string[]) => Promise<HeadObject[] | null>;
+/**
+ * Delete a file in S3 bucket
+ * @param bucket S3 bucket name
+ * @param s3path S3 file path to be deleted
+ * @returns true if delete is successful, null in case of error
+ */
+declare const deleteObject: (bucket: string, s3path: string) => Promise<true | null>;
+/**
+ * Delete a list of files in S3 bucket
+ * @param bucket S3 bucket name
+ * @param s3paths list of S3 file paths to be deleted
+ * @returns true if all deletes are successful, null in case of error
+ */
+declare const deleteObjectsAll: (bucket: string, s3paths: string[]) => Promise<true | null>;
+interface HeadObject {
+    Key: string;
+    ContentLength?: number;
+    ContentType?: string;
+    ETag?: string;
+    CacheControl?: string;
+    Expires?: Date;
+    LastModified?: Date;
+    Metadata?: StringIndexable;
+}
+
+type s3_HeadObject = HeadObject;
+declare const s3_deleteObject: typeof deleteObject;
+declare const s3_deleteObjectsAll: typeof deleteObjectsAll;
+declare const s3_downloadFile: typeof downloadFile;
+declare const s3_getObject: typeof getObject;
+declare const s3_getObjectHead: typeof getObjectHead;
+declare const s3_getObjectHeadsAll: typeof getObjectHeadsAll;
+declare const s3_listObjects: typeof listObjects;
+declare const s3_putObject: typeof putObject;
+declare const s3_uploadFile: typeof uploadFile;
+declare const s3_uploadFilesAll: typeof uploadFilesAll;
+declare namespace s3 {
+  export { type s3_HeadObject as HeadObject, s3_deleteObject as deleteObject, s3_deleteObjectsAll as deleteObjectsAll, s3_downloadFile as downloadFile, s3_getObject as getObject, s3_getObjectHead as getObjectHead, s3_getObjectHeadsAll as getObjectHeadsAll, init$1 as init, s3_listObjects as listObjects, s3_putObject as putObject, status$1 as status, s3_uploadFile as uploadFile, s3_uploadFilesAll as uploadFilesAll };
+}
+
+/**
+ * @deprecated explicit init deprecated!
+ */
+declare const init: (region: string) => Promise<boolean>;
+declare const status: () => {
+    db: string | null;
+    s3: string | null;
+};
+
+declare const aws_db: typeof db;
+declare const aws_init: typeof init;
+declare const aws_s3: typeof s3;
+declare const aws_status: typeof status;
+declare namespace aws {
+  export { aws_db as db, aws_init as init, aws_s3 as s3, aws_status as status };
+}
+
+interface GitHubContent {
+    path: string;
+    content: string;
+    sha: string;
+}
+/**
+ * Initialize GitHub client
+ * @param authToken GitHub auth token for the user account [GITHUB_TOKEN]
+ * @param owner account id for the GitHub user account [GITHUB_ACCOUNT]
+ * @returns an instance of GitHubClient
+ */
+declare function getInstance(authToken: string, owner: string): GitHubClient;
+declare class GitHubClient {
+    private client;
+    private owner;
+    constructor(authToken: string, owner: string);
+    /**
+     * Get contents of a particular file in a repo
+     * @param repo name of the repo
+     * @param path path of a file in the repo
+     * @returns an object {data, headers} containing normalized file content and response headers
+     * @throws {GitHubError} in case of failure or invalid response
+     */
+    getContent(repo: string, path: string): Promise<{
+        data: GitHubContent;
+        headers: Record<string, unknown>;
+    }>;
+}
+
+type gh_GitHubClient = GitHubClient;
+declare const gh_GitHubClient: typeof GitHubClient;
+type gh_GitHubContent = GitHubContent;
+declare const gh_getInstance: typeof getInstance;
+declare namespace gh {
+  export { gh_GitHubClient as GitHubClient, type gh_GitHubContent as GitHubContent, gh_getInstance as getInstance };
+}
+
+/**
+ * Generate SHA1 hash from given data
+ * @param input data string for which SHA1 hash has to be generated
+ * @returns SHA1 hash of the given data
+ */
+declare function sha1Hash(input: string): string;
+/**
+ * Generate SHA256 hash from given data
+ * @param input data string for which SHA256 hash has to be generated
+ * @returns SHA256 hash of the given data
+ */
+declare function sha256Hash(input: string | Buffer): string | null;
+
+declare const assertPath: (p: string) => string;
+declare const fileHash: (file: string) => Promise<string | null>;
+/**
+ * base64-encode given data
+ * @param data data string to be base64-encoded
+ * @returns base64-encoded string
+ */
+declare const base64Encode: (data: string) => string;
+/**
+ * decode base64-encoded data
+ * @param base64 base64 string to be decoded
+ * @returns base64-decoded string
+ */
+declare const base64Decode: (base64: string) => string;
+/**
+ * Create a Map from a given Array based on some field
+ * Note that the items of the array should generally be of type `object`
+ * so that the `key` property exists on the object item. However, if the
+ * `key` parameter is not provided, then the items of the array must be of
+ * a primitive data type (string or number) which will be treated as key.
+ * @param arr given Array to be converted to Map
+ * @param key [optional] a string field from Array items
+ * @returns a map created from the array items
+ */
+declare const arrayToMap: <T = any>(arr: T[] | null, key?: string) => Map<string, T> | null;
+/**
+ * Convert an array into an array of chunks of array
+ * @param arr a given array
+ * @param chunkSize maximum number of items in a chunk
+ * @returns array of chunks of the given array
+ */
+declare const chunkifyArray: <T = any>(arr: T[], chunkSize: number) => T[][];
+
+declare const utils_arrayToMap: typeof arrayToMap;
+declare const utils_assertPath: typeof assertPath;
+declare const utils_base64Decode: typeof base64Decode;
+declare const utils_base64Encode: typeof base64Encode;
+declare const utils_chunkifyArray: typeof chunkifyArray;
+declare const utils_fileHash: typeof fileHash;
+declare const utils_sha1Hash: typeof sha1Hash;
+declare const utils_sha256Hash: typeof sha256Hash;
+declare namespace utils {
+  export { utils_arrayToMap as arrayToMap, utils_assertPath as assertPath, utils_base64Decode as base64Decode, utils_base64Encode as base64Encode, utils_chunkifyArray as chunkifyArray, utils_fileHash as fileHash, utils_sha1Hash as sha1Hash, utils_sha256Hash as sha256Hash };
+}
+
+declare const _default: {
+    fs: typeof fs;
+    aws: typeof aws;
+    gh: typeof gh;
+    utils: typeof utils;
+};
+
+export { aws, _default as default, fs, gh, utils };