@helloao/cli 0.0.18 → 0.0.19

package/dist/types/actions.d.ts

@@ -0,0 +1,240 @@
+import { InputTranslationMetadata } from '@helloao/tools/generation/index.js';
+import { UploadApiFromDatabaseOptions, UploadApiOptions } from './uploads.js';
+export interface GetTranslationsItem {
+    id: string;
+    language: string;
+    direction: 'ltr' | 'rtl';
+    year: number;
+    name_local: string;
+    name_english: string;
+    name_abbrev: string;
+    attribution: string;
+    attribution_url: string;
+    licenses: RuntimeLicense[];
+}
+export interface RuntimeLicense {
+    id: string | null;
+    name: string;
+    restrictions: MetaRestrictions;
+    url: string;
+}
+export interface MetaRestrictions {
+    limit_verses: number | null;
+    limit_book_ratio: number | null;
+    limit_content_ratio: number | null;
+    forbid_commercial: boolean;
+    forbid_derivatives: boolean | 'same-license';
+    forbid_attributionless: boolean;
+    forbid_other: boolean;
+}
+export interface InitDbOptions {
+    /**
+     * The path to the source database to copy the schema from.
+     */
+    source?: string;
+    /**
+     * Whether to overwrite the existing database.
+     */
+    overwrite?: boolean;
+    /**
+     * The languages to copy from the source database. If not specified, then all languages will be copied.
+     */
+    language?: string[];
+}
+export interface ConvertToUsx3Options {
+    /**
+     * Whether to overwrite existing files in output directory.
+     */
+    overwrite?: boolean;
+}
+export interface SourceTranslationsOptions {
+    /**
+     * Whether to convert USFM files to USX3 format after download.
+     */
+    convertToUsx3?: boolean;
+    /**
+     * Options for USX3 conversion.
+     */
+    conversionOptions?: ConvertToUsx3Options;
+    /**
+     * Whether to track downloads in database.
+     */
+    useDatabase?: boolean;
+    /**
+     * Path to BibleMultiConverter.jar file. If not provided, will search common locations.
+     */
+    bibleMultiConverterPath?: string;
+    /**
+     * Whether to overwrite existing files in output directory.
+     *
+     * If database tracking is enabled, this will prevent overwriting files that were not tracked in the database.
+     */
+    overwrite?: boolean;
+    /**
+     * The database to use for tracking downloads.
+     */
+    db?: string | null;
+}
+export declare function getMetaPath(): Promise<string | null>;
+/**
+ * Initializes a new Bible API DB.
+ * @param dbPath The path to the database. If null or empty, then the "bible-api.db" will be used from the current working directory.
+ * @param options The options for the initialization.
+ */
+export declare function initDb(dbPath: string | null, options: InitDbOptions): Promise<void>;
+export interface ImportTranslationOptions {
+    /**
+     * Whether to forcibly import the translations, even if they have already been imported.
+     */
+    overwrite?: boolean;
+    /**
+     * The database to import the translations into.
+     */
+    db?: string | null;
+}
+/**
+ * Imports a translation from the given directory into the database in the current working directory.
+ * @param dir The directory that the translation is located in.
+ * @param dirs Any extra directories that should be imported.
+ * @param options The options for the import.
+ */
+export declare function importTranslation(dir: string, dirs: string[], options: ImportTranslationOptions): Promise<void>;
+/**
+ * Imports all the translations from the given directory into the database in the current working directory.
+ * @param dir The directory that the translations are located in.
+ * @param options The options.
+ */
+export declare function importTranslations(dir: string, options: ImportTranslationOptions): Promise<void>;
+/**
+ * Imports a commentary from the given directory into the database in the current working directory.
+ * @param dir The directory that the commentary is located in.
+ * @param dirs Any extra directories that should be imported.
+ * @param options The options for the import.
+ */
+export declare function importCommentary(dir: string, dirs: string[], options: ImportTranslationOptions): Promise<void>;
+/**
+ * Imports all the commentaries from the given directory into the database in the current working directory.
+ * @param dir The directory that the commentaries are located in.
+ * @param options The options.
+ */
+export declare function importCommentaries(dir: string, options: ImportTranslationOptions): Promise<void>;
+/**
+ * Imports the API from the given directory into the database in the current working directory.
+ * @param dir The directory that the API is located in.
+ * @param options The options.
+ */
+export declare function importApi(dir: string, options: ImportTranslationOptions): Promise<void>;
+export interface FetchTranslationsOptions {
+    /**
+     * Fetch all translations. If omitted, only undownloaded translations will be fetched.
+     */
+    all?: boolean;
+}
+/**
+ * Fetches the specified audio translations and places them in the given directory.
+ * Translations should be in the format "translationId/audioId". e.g. "BSB/gilbert"
+ * @param dir The directory that the translations should be placed in.
+ * @param translations The translations that should be downloaded.
+ * @param options The options.
+ */
+export declare function fetchAudio(dir: string, translations: string[], options?: FetchTranslationsOptions): Promise<void>;
+/**
+ * Generates the translation files directly from the translations stored in the given input directory.
+ * @param input The input directory that the translations are stored in.
+ * @param dest The destination to upload the API files to.
+ * @param options The options for the generation.
+ */
+export declare function generateTranslationsFiles(input: string, dest: string, options: UploadApiFromDatabaseOptions): Promise<void>;
+/**
+ * Instructions for manual USFM to USX3 conversion using BibleMultiConverter
+ */
+export declare const CONVERSION_INSTRUCTIONS: {
+    downloadUrl: string;
+    javaRequirement: string;
+    getConversionCommand: (inputDir: string, outputDir: string, filenamePattern?: string) => string;
+    examples: {
+        windows: string;
+        unix: string;
+    };
+};
+/**
+ * Prints conversion instructions for the user
+ */
+export declare function printConversionInstructions(): void;
+/**
+ * Downloads and processes USFM files from eBible.org.
+ * Can optionally convert to USX3 format and/or track in database.
+ */
+export declare function sourceTranslations(outputDir: string, translations?: string[], options?: SourceTranslationsOptions): Promise<void>;
+export declare function listEBibleTranslations(searchTerm?: string): Promise<void>;
+/**
+ * Generates the translation files directly from the translation stored in the given input directory.
+ * @param input The input directory that the translation is stored in.
+ * @param dest The destination to upload the API files to.
+ * @param options The options for the generation.
+ */
+export declare function generateTranslationFiles(input: string, dest: string, options: UploadApiOptions): Promise<void>;
+/**
+ * The options for uploading the test translations.
+ */
+export interface UploadTestTranslationOptions extends UploadApiOptions {
+    /**
+     * The s3 URL to upload the translations to.
+     * Defaults to "s3://ao-bible-api-public-uploads"
+     */
+    s3Url?: string;
+    /**
+     * The metadata that should be used for the translation.
+     */
+    translationMetadata?: InputTranslationMetadata;
+    /**
+     * The map of book IDs to common names.
+     */
+    bookNameMap?: Map<string, {
+        commonName: string;
+    }>;
+}
+export interface UploadTestTranslationResult {
+    /**
+     * The S3 URL where the translations were uploaded to.
+     */
+    uploadS3Url: string;
+    /**
+     * The HTTP URL that the version can be accessed at.
+     */
+    url: string;
+    /**
+     * The URL that the available translations can be accessed at.
+     */
+    availableTranslationsUrl: string;
+    /**
+     * The version that was uploaded.
+     * This is a SHA-256 hash of the input files.
+     */
+    version: string;
+}
+/**
+ * Generates the API files directly from the translations stored in the given input directory and
+ * uploads them to the HelloAO test s3 bucket.
+ *
+ * Requires access to the HelloAO test s3 bucket. Email hello@helloao.org for access.
+ *
+ * @param input The input directory that the translations are stored in.
+ * @param options The options to use for the upload.
+ */
+export declare function uploadTestTranslations(input: string, options: UploadTestTranslationOptions): Promise<UploadTestTranslationResult>;
+/**
+ * Generates the API files directly from the given translation and
+ * uploads them to the HelloAO test s3 bucket.
+ *
+ * Requires access to the HelloAO test s3 bucket. Email hello@helloao.org for access.
+ *
+ * @param input The input directory that the translations are stored in.
+ * @param options The options to use for the upload.
+ */
+export declare function uploadTestTranslation(input: string, options: UploadTestTranslationOptions): Promise<UploadTestTranslationResult | undefined>;
+/**
+ * Asks the user for the metadata for the translation.
+ */
+export declare function askForMetadata(defaultId?: string): Promise<InputTranslationMetadata>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/types/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/types/conversion.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Finds BibleMultiConverter.jar automatically in common locations
+ */
+export declare function findBibleMultiConverterJar(providedPath?: string): Promise<string | null>;
+/**
+ * Prompts user for BibleMultiConverter.jar location
+ */
+export declare function promptForBibleMultiConverter(): Promise<string | null>;
+/**
+ * Converts USFM directory to USX3 using BibleMultiConverter
+ */
+export declare function convertUsfmToUsx3(inputDir: string, outputDir: string, jarPath: string): Promise<boolean>;
+//# sourceMappingURL=conversion.d.ts.map

package/dist/types/db.d.ts

@@ -0,0 +1,157 @@
+import { PrismaClient } from './prisma-gen/index.js';
+import { Database } from 'better-sqlite3';
+import { DatasetCommentary, DatasetCommentaryBook, DatasetCommentaryProfile, DatasetDataset, DatasetDatasetBook, DatasetOutput, DatasetTranslation, DatasetTranslationBook } from '@helloao/tools/generation/dataset.js';
+import { InputFile, TranslationBookChapter, CommentaryBookChapter, DatasetBookChapter } from '@helloao/tools/generation/index.js';
+import { GenerateApiOptions } from '@helloao/tools/generation/api.js';
+import type { DOMParser } from 'linkedom';
+import { Readable } from 'stream';
+export declare function getMigrationsPath(): Promise<string | null>;
+/**
+ * Imports the translations from the given directories into the database.
+ * @param db The database to import the translations into.
+ * @param dirs The directories to import the translations from.
+ * @param parser The DOM parser that should be used for USX files.
+ * @param overwrite Whether to force a reload of the translations.
+ */
+export declare const importTranslations: (db: Database, dirs: string[], parser: DOMParser, overwrite: boolean) => Promise<void>;
+/**
+ * Imports the commentaries from the given directories into the database.
+ * @param db The database to import the commentaries into.
+ * @param dirs The directories to import the commentaries from.
+ * @param parser The DOM parser that should be used for USX files.
+ * @param overwrite Whether to force a reload of the commentaries.
+ */
+export declare const importCommentaries: (db: Database, dirs: string[], parser: DOMParser, overwrite: boolean) => Promise<void>;
+/**
+ * Imports the files from the given directories into the database.
+ * @param loadFilesFromDir The function that should be used to load the files from the given directory.
+ * @param db The database to import the files into.
+ * @param dirs The directories to import the files from.
+ * @param parser The DOM parser that should be used for USX files.
+ * @param overwrite Whether to force a reload of the files.
+ */
+export declare function importFiles(loadFilesFromDir: (path: string) => Promise<InputFile[] | null>, db: Database, dirs: string[], parser: DOMParser, overwrite: boolean): Promise<void>;
+/**
+ * Imports a batch of translations from the given directories into the database.
+ * @param db The database to import the translations into.
+ * @param dirs The directories that contain the translations.
+ * @param parser The DOM parser that should be used for USX files.
+ * @param overwrite Whether to force a reload of the translations.
+ */
+export declare const importTranslationBatch: (db: Database, dirs: string[], parser: DOMParser, overwrite: boolean) => Promise<void>;
+/**
+ * Imports a batch of files from the given directories into the database.
+ * @param loadFilesFromDir The function that should be used to load the files from the given directory.
+ * @param db The database to import the files into.
+ * @param dirs The directories that contain the files.
+ * @param parser The DOM parser that should be used for USX files.
+ * @param overwrite Whether to force a reload of the files.
+ */
+export declare function loadAndImportBatch(loadFilesFromDir: (path: string) => Promise<InputFile[] | null>, db: Database, dirs: string[], parser: DOMParser, overwrite: boolean): Promise<void>;
+/**
+ * Parses and imports the given files into the database.
+ * @param db The database to import the files into.
+ * @param files The files that should be parsed.
+ * @param parser The DOM parser that should be used for USX files.
+ * @param overwrite Whether to force a reload of the translations.
+ */
+export declare function importFileBatch(db: Database, files: InputFile[], parser: DOMParser, overwrite: boolean): Promise<void>;
+/**
+ * Imports the given dataset output into the database.
+ * @param db The database to import the dataset into.
+ * @param output The dataset output to import.
+ */
+export declare function importDatasetOutput(db: Database, output: DatasetOutput): void;
+/**
+ * Filters the given input files to only include those that have changed.
+ * @param db The database to check for changes.
+ * @param files The files to filter.
+ */
+export declare function getChangedOrNewInputFiles(db: Database, files: InputFile[]): InputFile[];
+export declare function insertFileMetadata(db: Database, files: InputFile[]): void;
+export declare function insertTranslations(db: Database, translations: DatasetTranslation[]): void;
+export declare function insertTranslationBooks(db: Database, translation: DatasetTranslation, translationBooks: DatasetTranslationBook[]): void;
+export declare function insertTranslationContent(db: Database, translation: DatasetTranslation, book: DatasetTranslationBook, chapters: TranslationBookChapter[]): void;
+export declare function insertCommentaries(db: Database, commentaries: DatasetCommentary[]): void;
+export declare function insertCommentaryBooks(db: Database, commentary: DatasetCommentary, commentaryBooks: DatasetCommentaryBook[]): void;
+export declare function insertCommentaryProfiles(db: Database, commentary: DatasetCommentary, commentaryProfiles: DatasetCommentaryProfile[]): void;
+export declare function insertCommentaryContent(db: Database, commentary: DatasetCommentary, book: DatasetCommentaryBook, chapters: CommentaryBookChapter[]): void;
+export declare function insertDatasets(db: Database, datasets: DatasetDataset[]): void;
+export declare function insertDatasetBooks(db: Database, dataset: DatasetDataset, datasetBooks: DatasetDatasetBook[]): void;
+export declare function insertDatasetContent(db: Database, dataset: DatasetDataset, book: DatasetDatasetBook, chapters: DatasetBookChapter[]): void;
+export declare function getDbPathFromDir(dir: string): string;
+export declare function getDbPath(p?: string | null): string;
+export declare function getPrismaDb(path?: string | null): PrismaClient<{
+    datasources: {
+        db: {
+            url: string;
+        };
+    };
+}, never, import("prisma-gen/runtime/library.js").DefaultArgs>;
+/**
+ * Gets the database from the given path. If no path is provided, the current working directory is used.
+ * @param path The path to the database. If not provided, the current working directory is used.
+ * @returns
+ */
+export declare function getDb(path?: string | null): Promise<Database>;
+export interface SerializedFile {
+    path: string;
+    content: string | Readable;
+    /**
+     * Gets the base64-encoded SHA256 hash of the content of the file.
+     */
+    sha256?(): string;
+}
+/**
+ * Loads the datasets from the database in a series of batches.
+ * @param db The database.
+ * @param perBatch The number of translations to load per batch.
+ * @param translationsToLoad The list of translations/commentaries to load. If not provided, all translations will be loaded.
+ */
+export declare function loadDatasets(db: PrismaClient, perBatch?: number, translationsToLoad?: string[]): AsyncGenerator<DatasetOutput>;
+/**
+ * Loads the translations from the database as a dataset.
+ * @param db The database.
+ * @param translationsPerBatch The number of translations to load per batch.
+ * @param translationsToLoad The list of translations to load. If not provided, all translations will be loaded.
+ */
+export declare function loadTranslationDatasets(db: PrismaClient, translationsPerBatch?: number, translationsToLoad?: string[]): AsyncGenerator<DatasetOutput, void, unknown>;
+/**
+ * Loads the commentaries from the database as a dataset.
+ * @param db The database.
+ * @param perBatch The number of translations to load per batch.
+ * @param commentariesToLoad The list of commentaries to load. If not provided, all commentaries will be loaded.
+ */
+export declare function loadCommentaryDatasets(db: PrismaClient, perBatch?: number, commentariesToLoad?: string[]): AsyncGenerator<DatasetOutput, void, unknown>;
+/**
+ * Loads the datasets from the database as a dataset.
+ * @param db The database.
+ * @param perBatch The number of translations to load per batch.
+ * @param datasetsToLoad The list of commentaries to load. If not provided, all commentaries will be loaded.
+ */
+export declare function loadDatasetDatasets(db: PrismaClient, perBatch?: number, datasetsToLoad?: string[]): AsyncGenerator<DatasetOutput, void, unknown>;
+export interface SerializeApiOptions extends GenerateApiOptions {
+    /**
+     * Whether the output should be pretty-printed.
+     */
+    pretty?: boolean;
+}
+/**
+ * Generates and serializes the API files for the datasets that are stored in the database.
+ * Yields each batch of serialized files.
+ * @param db The database that the dataset should be loaded from.
+ * @param options The options to use for serializing the files.
+ * @param apiOptions The options to use for generating the API files.
+ * @param translationsPerBatch The number of translations that should be loaded and written per batch.
+ * @param translations The list of translations that should be loaded. If not provided, all translations will be loaded.
+ */
+export declare function serializeFilesFromDatabase(db: PrismaClient, options?: SerializeApiOptions, translationsPerBatch?: number, translations?: string[]): AsyncGenerator<SerializedFile[]>;
+/**
+ * Generates and serializes the API files for the given datasets.
+ * Yields each batch of serialized files.
+ *
+ * @param datasets The datasets to serialize.
+ * @param options The options to use for generating and serializing the files.
+ */
+export declare function serializeDatasets(datasets: AsyncIterable<DatasetOutput>, options?: SerializeApiOptions): AsyncGenerator<SerializedFile[]>;
+//# sourceMappingURL=db.d.ts.map

package/dist/types/downloads.d.ts

@@ -0,0 +1,14 @@
+import { Entry, ZipReader } from '@zip.js/zip.js';
+export declare function downloadFile(url: string, path: string, onProgress?: (progress: number) => void): Promise<void>;
+export declare function downloadResponse(response: Response, path: string, onProgress?: (progress: number) => void): Promise<void>;
+/**
+ * Unzips a ZipReader to a specified directory.
+ * @param zip The ZipReader instance to read from.
+ * @param directory The directory to unzip files into.
+ * @param overwrite Wether to overwrite existing files.
+ * @param entryFilter A filter function to determine which entries to unzip.
+ * @param closeWhenDone Whether to close the ZipReader when done.
+ * @returns The number of files that matched the entry filter.
+ */
+export declare function unzipToDirectory(zip: ZipReader<unknown>, directory: string, overwrite: boolean, entryFilter?: (entry: Entry) => boolean, closeWhenDone?: boolean): Promise<number>;
+//# sourceMappingURL=downloads.d.ts.map

package/dist/types/ebible.d.ts

@@ -0,0 +1,6 @@
+import { EBibleSource } from 'prisma-gen/index.js';
+/**
+ * Fetches eBible translation metadata and returns EBibleSource objects.
+ */
+export declare function fetchEBibleMetadata(): Promise<EBibleSource[]>;
+//# sourceMappingURL=ebible.d.ts.map

package/dist/types/files.d.ts

@@ -0,0 +1,136 @@
+import { InputFile, InputTranslationMetadata, OutputFile } from '@helloao/tools/generation/common-types.js';
+import { Readable } from 'stream';
+import { DatasetDataset } from '@helloao/tools/generation/dataset.js';
+/**
+ * Defines an interface that contains information about a serialized file.
+ */
+export interface Uploader {
+    /**
+     * Gets the ideal batch size for the uploader.
+     * Null if the uploader does not need batching.
+     */
+    idealBatchSize: number | null;
+    /**
+     * Uploads the given file.
+     * @param file The file to upload.
+     * @param overwrite Whether the file should be overwritten if it already exists.
+     * @returns True if the file was uploaded. False if the file was skipped due to already existing.
+     */
+    upload(file: SerializedFile, overwrite: boolean): Promise<boolean>;
+    /**
+     * Disposes resources that the uploader uses.
+     */
+    dispose?(): Promise<void>;
+}
+/**
+ * Defines an interface for a file that has been serialized.
+ */
+export interface SerializedFile {
+    path: string;
+    content: string | Readable;
+    /**
+     * Gets the base64-encoded SHA256 hash of the content of the file.
+     */
+    sha256?(): string;
+}
+/**
+ * The options for serializing API files.
+ */
+export interface SerializeApiOptions {
+    /**
+     * Whether the output should be pretty-printed.
+     */
+    pretty?: boolean;
+}
+/**
+ * Serializes the given output files into serialized files using the given options.
+ *
+ * Each iteration of the given files will be processed as a batch, and any mergable files will automatically be merged together and serialized in the final batch.
+ *
+ * @param files The files that should be serialized.
+ * @param options The options for serialization.
+ */
+export declare function serializeOutputFiles(files: AsyncIterable<OutputFile[]>, options: SerializeApiOptions): AsyncGenerator<SerializedFile[]>;
+/**
+ * Serializes the given output file content into a serialized file.
+ * @param path The path that the file should be saved to.
+ * @param content The content of the file.
+ * @param options The options for serialization.
+ */
+export declare function serializeFile(path: string, content: OutputFile['content'], options: SerializeApiOptions): Promise<SerializedFile | null>;
+/**
+ * Loads the files for the given translations.
+ * @param dir The directory that the translations exist in.
+ */
+export declare function loadTranslationsFiles(dirs: string[]): Promise<InputFile[]>;
+/**
+ * Loads the files for the given translation.
+ * @param translation The directory that the translation exists in.
+ * @returns The list of files that were loaded, or null if the translation has no metadata.
+ */
+export declare function loadTranslationFiles(translation: string, translationMetadata?: InputTranslationMetadata): Promise<InputFile[] | null>;
+/**
+ * Loads the files for the given commentaries.
+ * @param dir The directory that the commentaries exist in.
+ */
+export declare function loadCommentariesFiles(dirs: string[]): Promise<InputFile[]>;
+/**
+ * Loads the files for the given commentary.
+ * @param commentary The directory that the commentary exists in.
+ * @returns The list of files that were loaded, or null if the commentary has no metadata.
+ */
+export declare function loadCommentaryFiles(commentary: string): Promise<InputFile[] | null>;
+/**
+ * Imports all the datasets from the given directory into the database in the current working directory.
+ * @param dir The directory that the datasets are located in.
+ * @param options The options.
+ */
+export declare function loadDatasetsFromDirectory(dir: string): Promise<DatasetDataset[]>;
+export interface CollectionTranslationMetadata {
+    name: {
+        local: string;
+        abbrev: string;
+        english: string;
+    };
+    language: string;
+    year: number;
+    direction: 'ltr' | 'rtl';
+    copyright: {
+        licenses: any[];
+        attribution: string;
+        attribution_url: string;
+    };
+    id: string | null;
+    source: {
+        id: string;
+    };
+}
+/**
+ * Defines an uploader that is able to upload files to a directory.
+ */
+export declare class FilesUploader implements Uploader {
+    private _dir;
+    constructor(dir: string);
+    get idealBatchSize(): number | null;
+    upload(file: SerializedFile, overwrite: boolean): Promise<boolean>;
+}
+/**
+ * Defines an uploader that is able to upload files into a zip file.
+ */
+export declare class ZipUploader implements Uploader {
+    private _path;
+    private _initPromise;
+    private _fileHandle;
+    private _zip;
+    constructor(filePath: string);
+    private _init;
+    get idealBatchSize(): number | null;
+    upload(file: SerializedFile, _overwrite: boolean): Promise<boolean>;
+    dispose(): Promise<void>;
+}
+/**
+ * Calculates the SHa256 hash of the given input files.
+ * @param files The files to hash.
+ */
+export declare function hashInputFiles(files: InputFile[]): string;
+//# sourceMappingURL=files.d.ts.map

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+import * as db from './db.js';
+import * as downloads from './downloads.js';
+import * as uploads from './uploads.js';
+import * as actions from './actions.js';
+import * as files from './files.js';
+import * as s3 from './s3.js';
+export { db, downloads, uploads, actions, files, s3 };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/s3.d.ts

@@ -0,0 +1,44 @@
+import { SerializedFile, Uploader } from './files.js';
+import { AwsCredentialIdentity, Provider } from '@smithy/types';
+export declare class S3Uploader implements Uploader {
+    private _client;
+    private _bucketName;
+    private _keyPrefix;
+    get idealBatchSize(): number;
+    constructor(bucketName: string, keyPrefix: string, profile: string | null | AwsCredentialIdentity | Provider<AwsCredentialIdentity>, region?: string);
+    upload(file: SerializedFile, overwrite: boolean): Promise<boolean>;
+}
+/**
+ * Parses the given S3 URL into its bucket name and object key.
+ * @param url The URL to parse.
+ */
+export declare function parseS3Url(url: string): {
+    bucketName: string;
+    objectKey: string;
+} | undefined;
+/**
+ * Gets the HTTP URL for the given S3 URL.
+ * @param s3Url The S3 URL to convert.
+ */
+export declare function getHttpUrl(s3Url: string): string | undefined;
+/**
+ * A provider that gets the credentials directly from the user input.
+ */
+export declare const askForAccessKeyProvider: Provider<AwsCredentialIdentity>;
+/**
+ * Defines a provider that tries to get the credentials from the given list of providers.
+ * @param providers The providers to try.
+ */
+export declare function providerChain(...providers: Provider<AwsCredentialIdentity>[]): Provider<AwsCredentialIdentity>;
+/**
+ * Gets the default provider for the given options.
+ *
+ * Defaults first to using the provided access key and secret access key, then to using the given profile, then finally to asking the user for the access key.
+ * @param options
+ */
+export declare function defaultProviderForOptions(options: {
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    profile?: string;
+}): Provider<AwsCredentialIdentity> | AwsCredentialIdentity;
+//# sourceMappingURL=s3.d.ts.map