@bitblit/ratchet-aws 4.0.80-alpha

package/dist/types/batch/aws-batch-background-processor.d.ts

@@ -0,0 +1,12 @@
+import { SubmitJobCommandOutput } from '@aws-sdk/client-batch';
+import { AwsBatchRatchet } from './aws-batch-ratchet';
+/**
+ * Class to simplify using AWS batch as a background processor
+ * (Primarily used by Epsilon)
+ */
+export declare class AwsBatchBackgroundProcessor {
+    private batchRatchet;
+    private validTaskNames?;
+    constructor(batchRatchet: AwsBatchRatchet, validTaskNames?: string[]);
+    scheduleBackgroundTask(taskName: string, data?: Record<string, any>, meta?: Record<string, any>): Promise<SubmitJobCommandOutput>;
+}

package/dist/types/batch/aws-batch-ratchet.d.ts

@@ -0,0 +1,16 @@
+import { BatchClient, JobStatus, JobSummary, SubmitJobCommandInput, SubmitJobCommandOutput } from '@aws-sdk/client-batch';
+/**
+ * Ratchet for simplifying interacting with AWS Batch
+ */
+export declare class AwsBatchRatchet {
+    private _batchClient;
+    private _defaultQueueName?;
+    private _defaultJobDefinition?;
+    constructor(_batchClient: BatchClient, _defaultQueueName?: string, _defaultJobDefinition?: string);
+    get batchClient(): BatchClient;
+    get defaultQueueName(): string;
+    get defaultJobDefinition(): string;
+    scheduleJob(options: SubmitJobCommandInput): Promise<SubmitJobCommandOutput>;
+    jobCountInState(jobStatus: JobStatus, queueName?: string): Promise<number>;
+    listJobs(queueName?: string, jobStatus?: JobStatus): Promise<JobSummary[]>;
+}

package/dist/types/build/ratchet-aws-info.d.ts

@@ -0,0 +1,5 @@
+import { BuildInformation } from '@bitblit/ratchet-common';
+export declare class RatchetAwsInfo {
+    private constructor();
+    static buildInformation(): BuildInformation;
+}

package/dist/types/cache/dynamo-db-storage-provider.d.ts

@@ -0,0 +1,25 @@
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper';
+import { SimpleCacheStorageProvider } from './simple-cache-storage-provider';
+import { DynamoRatchet } from '../dynamodb/dynamo-ratchet';
+export declare class DynamoDbStorageProvider implements SimpleCacheStorageProvider {
+    private dynamo;
+    private opts;
+    constructor(dynamo: DynamoRatchet, opts: DynamoDbSimpleCacheOptions);
+    static createDefaultOptions(): DynamoDbSimpleCacheOptions;
+    createKeyObject(cacheKey: string): any;
+    cleanDynamoFieldsFromObjectInPlace(rval: any): void;
+    extractKeysFromObject(rval: SimpleCacheObjectWrapper<any>): any;
+    readFromCache<T>(cacheKey: string): Promise<SimpleCacheObjectWrapper<T>>;
+    storeInCache<T>(value: SimpleCacheObjectWrapper<T>): Promise<boolean>;
+    removeFromCache(cacheKey: string): Promise<void>;
+    clearCache(): Promise<number>;
+    readAll(): Promise<SimpleCacheObjectWrapper<any>[]>;
+}
+export interface DynamoDbSimpleCacheOptions {
+    tableName: string;
+    useRangeKeys: boolean;
+    hashKeyName: string;
+    rangeKeyName?: string;
+    hashKeyValue?: string;
+    dynamoExpiresColumnName?: string;
+}

package/dist/types/cache/s3-storage-provider.d.ts

@@ -0,0 +1,14 @@
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper';
+import { SimpleCacheStorageProvider } from './simple-cache-storage-provider';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
+export declare class S3StorageProvider implements SimpleCacheStorageProvider {
+    private s3CacheRatchet;
+    private prefix;
+    constructor(s3CacheRatchet: S3CacheRatchet, prefix: string);
+    keyToPath(cacheKey: string): string;
+    readFromCache<T>(cacheKey: string): Promise<SimpleCacheObjectWrapper<T>>;
+    storeInCache<T>(value: SimpleCacheObjectWrapper<T>): Promise<boolean>;
+    removeFromCache(cacheKey: string): Promise<void>;
+    clearCache(): Promise<number>;
+    readAll(): Promise<SimpleCacheObjectWrapper<any>[]>;
+}

package/dist/types/cache/simple-cache-object-wrapper.d.ts

@@ -0,0 +1,7 @@
+export interface SimpleCacheObjectWrapper<T> {
+    cacheKey: string;
+    createdEpochMS: number;
+    expiresEpochMS: number;
+    value: T;
+    generated: boolean;
+}

package/dist/types/cache/simple-cache-read-options.d.ts

@@ -0,0 +1,5 @@
+export interface SimpleCacheReadOptions {
+    maxStalenessMS: number;
+    timeToLiveMS: number;
+    cacheNullValues: boolean;
+}

package/dist/types/cache/simple-cache-storage-provider.d.ts

@@ -0,0 +1,8 @@
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper';
+export interface SimpleCacheStorageProvider {
+    readFromCache<T>(cacheKey: string): Promise<SimpleCacheObjectWrapper<T>>;
+    storeInCache<T>(value: SimpleCacheObjectWrapper<T>): Promise<boolean>;
+    removeFromCache(cacheKey: string): Promise<void>;
+    clearCache(): Promise<number>;
+    readAll(): Promise<SimpleCacheObjectWrapper<any>[]>;
+}

package/dist/types/cache/simple-cache.d.ts

@@ -0,0 +1,14 @@
+import { SimpleCacheStorageProvider } from './simple-cache-storage-provider';
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper';
+import { SimpleCacheReadOptions } from './simple-cache-read-options';
+export declare class SimpleCache {
+    private provider;
+    private defaultTimeToLiveMS;
+    constructor(provider: SimpleCacheStorageProvider, defaultTimeToLiveMS?: number);
+    createDefaultReadOptions(): SimpleCacheReadOptions;
+    fetchWrapper<T>(cacheKey: string, producer: () => Promise<T>, opts?: SimpleCacheReadOptions): Promise<SimpleCacheObjectWrapper<T>>;
+    fetch<T>(cacheKey: string, producer: () => Promise<T>, opts?: SimpleCacheReadOptions): Promise<T>;
+    removeFromCache<T>(cacheKey: string, returnOldValue?: boolean): Promise<SimpleCacheObjectWrapper<T>>;
+    clearCache(): Promise<number>;
+    readAll(): Promise<SimpleCacheObjectWrapper<any>[]>;
+}

package/dist/types/cloudwatch/cloud-watch-log-group-ratchet.d.ts

@@ -0,0 +1,9 @@
+import { CloudWatchLogsClient, FilteredLogEvent, LogStream } from '@aws-sdk/client-cloudwatch-logs';
+export declare class CloudWatchLogGroupRatchet {
+    private logGroup;
+    private awsCWLogs;
+    constructor(logGroup: string, awsCWLogs?: CloudWatchLogsClient);
+    readLogStreams(startTimestamp?: number, endTimestamp?: number): Promise<LogStream[]>;
+    readLogStreamNames(startTimestamp?: number, endTimestamp?: number): Promise<string[]>;
+    readEvents(filter: string, startTimestamp?: number, endTimestamp?: number, sortEvents?: boolean, maxEvents?: number): Promise<FilteredLogEvent[]>;
+}

package/dist/types/cloudwatch/cloud-watch-logs-ratchet.d.ts

@@ -0,0 +1,14 @@
+import { CloudWatchLogsClient, GetQueryResultsCommandOutput, LogGroup, LogStream, StartQueryCommandInput, StopQueryCommandOutput } from '@aws-sdk/client-cloudwatch-logs';
+export declare class CloudWatchLogsRatchet {
+    private static readonly MAX_DELETE_RETRIES;
+    private cwLogs;
+    constructor(cloudwatchLogs?: CloudWatchLogsClient);
+    removeEmptyOrOldLogStreams(logGroupName: string, maxToRemove?: number, oldestEventEpochMS?: number): Promise<LogStream[]>;
+    findOldestEventTimestampInGroup(logGroupName: string): Promise<number>;
+    findStreamWithOldestEventInGroup(logGroupName: string): Promise<LogStream>;
+    findLogGroups(prefix: string): Promise<LogGroup[]>;
+    removeLogGroups(groups: LogGroup[]): Promise<boolean[]>;
+    removeLogGroupsWithPrefix(prefix: string): Promise<boolean[]>;
+    fullyExecuteInsightsQuery(sqr: StartQueryCommandInput): Promise<GetQueryResultsCommandOutput>;
+    abortInsightsQuery(queryId: string): Promise<StopQueryCommandOutput>;
+}

package/dist/types/cloudwatch/cloud-watch-metrics-ratchet.d.ts

@@ -0,0 +1,10 @@
+import { CloudWatchClient } from '@aws-sdk/client-cloudwatch';
+import { KeyValue } from '@bitblit/ratchet-common';
+import { CloudWatchMetricsUnit } from '../model/cloud-watch-metrics-unit';
+import { CloudWatchMetricsMinuteLevelDynamoCountRequest } from '../model/cloud-watch-metrics-minute-level-dynamo-count-request';
+export declare class CloudWatchMetricsRatchet {
+    private cw;
+    constructor(cloudWatch?: CloudWatchClient);
+    writeSingleMetric(namespace: string, metric: string, dims: KeyValue[], unit: CloudWatchMetricsUnit, value: number, timestampDate?: Date, highResolution?: boolean): Promise<any>;
+    writeDynamoCountAsMinuteLevelMetric(req: CloudWatchMetricsMinuteLevelDynamoCountRequest): Promise<number>;
+}

package/dist/types/daemon/daemon-like.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { DaemonProcessState } from './daemon-process-state';
+import { DaemonProcessCreateOptions } from './daemon-process-create-options';
+export interface DaemonLike {
+    get defaultGroup(): string;
+    keyToPublicToken(key: string, expirationSeconds: number): Promise<string>;
+    start(options: DaemonProcessCreateOptions): Promise<DaemonProcessState>;
+    clean(group?: string, olderThanSeconds?: number): Promise<DaemonProcessState[]>;
+    listKeys(group?: string): Promise<string[]>;
+    list(group?: string): Promise<DaemonProcessState[]>;
+    updateMessage(id: string, newMessage: string): Promise<DaemonProcessState>;
+    statFromPublicToken(publicToken: string): Promise<DaemonProcessState>;
+    stat(key: string): Promise<DaemonProcessState>;
+    abort(id: string): Promise<DaemonProcessState>;
+    error(id: string, error: string): Promise<DaemonProcessState>;
+    finalize(id: string, contents: Buffer): Promise<DaemonProcessState>;
+}

package/dist/types/daemon/daemon-process-create-options.d.ts

@@ -0,0 +1,7 @@
+export interface DaemonProcessCreateOptions {
+    title: string;
+    contentType: string;
+    group: string;
+    meta: any;
+    targetFileName: string;
+}

package/dist/types/daemon/daemon-process-state-public-token.d.ts

@@ -0,0 +1,4 @@
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+export interface DaemonProcessStatePublicToken extends JwtTokenBase {
+    daemonKey: string;
+}

package/dist/types/daemon/daemon-process-state.d.ts

@@ -0,0 +1,13 @@
+export interface DaemonProcessState {
+    id: string;
+    title: string;
+    targetFileName: string;
+    lastUpdatedEpochMS: number;
+    lastUpdatedMessage: string;
+    startedEpochMS: number;
+    completedEpochMS: number;
+    meta: any;
+    error: string;
+    link: string;
+    contentType: string;
+}

package/dist/types/daemon/daemon-util.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { DaemonProcessState } from './daemon-process-state';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
+import { DaemonProcessCreateOptions } from './daemon-process-create-options';
+import { Readable } from 'stream';
+/**
+ * Internal utilities which are here for the USE OF THE DAEMON OBJECT ONLY - if you are trying to use this
+ * class outside of Ratchet, you are doing it wrong.  Instantiate a Daemon object and use that instead.
+ *
+ * The details of storage and retrieval of a DaemonProcessState is meant to be transparent to the user
+ */
+export declare class DaemonUtil {
+    static DEFAULT_CONTENT: Buffer;
+    static DAEMON_METADATA_KEY: string;
+    static start(cache: S3CacheRatchet, id: string, s3Key: string, options: DaemonProcessCreateOptions): Promise<DaemonProcessState>;
+    static writeState(cache: S3CacheRatchet, s3Key: string, newState: DaemonProcessState, contents: Buffer): Promise<DaemonProcessState>;
+    static streamDataAndFinish(cache: S3CacheRatchet, s3Key: string, data: Readable): Promise<DaemonProcessState>;
+    static updateMessage(cache: S3CacheRatchet, s3Key: string, newMessage: string): Promise<DaemonProcessState>;
+    static stat(s3Cache: S3CacheRatchet, path: string): Promise<DaemonProcessState>;
+    static abort(s3Cache: S3CacheRatchet, path: string): Promise<DaemonProcessState>;
+    static error(s3Cache: S3CacheRatchet, path: string, error: string): Promise<DaemonProcessState>;
+    static finalize(s3Cache: S3CacheRatchet, path: string, contents: Buffer): Promise<DaemonProcessState>;
+}

package/dist/types/daemon/daemon.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { DaemonProcessState } from './daemon-process-state';
+import { DaemonProcessCreateOptions } from './daemon-process-create-options';
+import { DaemonLike } from './daemon-like';
+import { JwtRatchetLike } from '@bitblit/ratchet-common';
+import { S3Client } from '@aws-sdk/client-s3';
+export declare class Daemon implements DaemonLike {
+    private s3;
+    private bucket;
+    private prefix;
+    private _defaultGroup;
+    private jwtRatchet?;
+    static DEFAULT_DEFAULT_GROUP: string;
+    private cache;
+    constructor(s3: S3Client, bucket: string, prefix?: string, _defaultGroup?: string, jwtRatchet?: JwtRatchetLike);
+    get defaultGroup(): string;
+    keyToPublicToken(key: string, expirationSeconds: number): Promise<string>;
+    private keyToPath;
+    private pathToKey;
+    private generatePath;
+    private generatePrefix;
+    start(options: DaemonProcessCreateOptions): Promise<DaemonProcessState>;
+    private writeState;
+    clean(group?: string, olderThanSeconds?: number): Promise<DaemonProcessState[]>;
+    listKeys(group?: string): Promise<string[]>;
+    list(group?: string): Promise<DaemonProcessState[]>;
+    updateMessage(id: string, newMessage: string): Promise<DaemonProcessState>;
+    stat(key: string): Promise<DaemonProcessState>;
+    statFromPublicToken(publicToken: string): Promise<DaemonProcessState>;
+    abort(id: string): Promise<DaemonProcessState>;
+    error(id: string, error: string): Promise<DaemonProcessState>;
+    finalize(id: string, contents: Buffer): Promise<DaemonProcessState>;
+}

package/dist/types/dao/prototype-dao-config.d.ts

@@ -0,0 +1,8 @@
+export interface PrototypeDaoConfig {
+    guidCreateFunction: () => string;
+    guidFieldName: string;
+    createdEpochMSFieldName?: string;
+    updatedEpochMSFieldName?: string;
+    createdUtcTimestampFieldName?: string;
+    updatedUtcTimestampFieldName?: string;
+}

package/dist/types/dao/prototype-dao-db.d.ts

@@ -0,0 +1,4 @@
+export interface PrototypeDaoDb<T> {
+    items: T[];
+    lastModifiedEpochMS: number;
+}

package/dist/types/dao/prototype-dao-provider.d.ts

@@ -0,0 +1,5 @@
+import { PrototypeDaoDb } from './prototype-dao-db';
+export interface PrototypeDaoProvider<T> {
+    storeDatabase(db: PrototypeDaoDb<T>): Promise<boolean>;
+    loadDatabase(): Promise<PrototypeDaoDb<T>>;
+}

package/dist/types/dao/prototype-dao.d.ts

@@ -0,0 +1,15 @@
+import { PrototypeDaoProvider } from './prototype-dao-provider';
+import { PrototypeDaoConfig } from './prototype-dao-config';
+export declare class PrototypeDao<T> {
+    private provider;
+    private cfg;
+    static defaultDaoConfig(): PrototypeDaoConfig;
+    constructor(provider: PrototypeDaoProvider<T>, cfg?: PrototypeDaoConfig);
+    fetchAll(): Promise<T[]>;
+    resetDatabase(): Promise<void>;
+    removeItems(guids: string[]): Promise<T[]>;
+    store(value: T): Promise<T>;
+    fetchById(guid: string): Promise<T>;
+    searchByField<R>(fieldDotPath: string, fieldValue: R): Promise<T[]>;
+    searchByFieldMap(input: Record<string, any>): Promise<T[]>;
+}

package/dist/types/dao/s3-prototype-dao-provider.d.ts

@@ -0,0 +1,10 @@
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
+import { PrototypeDaoProvider } from './prototype-dao-provider';
+import { PrototypeDaoDb } from './prototype-dao-db';
+export declare class S3PrototypeDaoProvider<T> implements PrototypeDaoProvider<T> {
+    private s3CacheRatchet;
+    private keyName;
+    constructor(s3CacheRatchet: S3CacheRatchet, keyName: string);
+    storeDatabase(inDb: PrototypeDaoDb<T>): Promise<boolean>;
+    loadDatabase(): Promise<PrototypeDaoDb<T>>;
+}

package/dist/types/dao/s3-simple-dao.d.ts

@@ -0,0 +1,15 @@
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
+import { SimpleDaoItem } from './simple-dao-item';
+export declare class S3SimpleDao<T extends SimpleDaoItem> {
+    private cache;
+    private prefix?;
+    constructor(cache: S3CacheRatchet, prefix?: string);
+    buildPathPrefix(path: string): string;
+    buildFullPath(id: string, path?: string): string;
+    exists(id: string, path?: string): Promise<boolean>;
+    fetch(id: string, path?: string): Promise<T>;
+    store(item: T, path?: string): Promise<T>;
+    listItems(path?: string): Promise<string[]>;
+    fetchItemsInPath(path?: string): Promise<T[]>;
+    delete(id: string, path?: string): Promise<boolean>;
+}

package/dist/types/dao/simple-dao-item.d.ts

@@ -0,0 +1,5 @@
+export interface SimpleDaoItem {
+    id: string;
+    path: string;
+    lastModifiedEpochMS: number;
+}

package/dist/types/dynamodb/dynamo-ratchet-like.d.ts

@@ -0,0 +1,27 @@
+import { DynamoCountResult } from '../model/dynamo-count-result';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import { DeleteItemCommandOutput, PutItemOutput } from '@aws-sdk/client-dynamodb';
+import { DocQueryCommandInput } from '../model/dynamo/doc-query-command-input';
+import { DocScanCommandInput } from '../model/dynamo/doc-scan-command-input';
+export interface DynamoRatchetLike {
+    getDDB(): DynamoDBDocumentClient;
+    tableIsEmpty(tableName: string): Promise<boolean>;
+    throughputSafeScanOrQuery<T, R>(proc: (T: any) => Promise<R>, input: T, maxTries?: number, inCurrentTry?: number): Promise<R>;
+    fullyExecuteQueryCount(qry: DocQueryCommandInput, delayMS?: number): Promise<DynamoCountResult>;
+    fullyExecuteQuery<T>(qry: DocQueryCommandInput, delayMS?: number, softLimit?: number): Promise<T[]>;
+    fullyExecuteProcessOverQuery<T>(qry: DocQueryCommandInput, proc: (val: T) => Promise<void>, delayMS?: number, softLimit?: number): Promise<number>;
+    fullyExecuteScanCount(scan: DocScanCommandInput, delayMS?: number): Promise<DynamoCountResult>;
+    fullyExecuteScan<T>(scan: DocScanCommandInput, delayMS?: number, softLimit?: number): Promise<T[]>;
+    fullyExecuteProcessOverScan<T>(scan: DocScanCommandInput, proc: (val: T) => Promise<void>, delayMS?: number, softLimit?: number): Promise<number>;
+    writeAllInBatches<T>(tableName: string, elements: T[], batchSize: number): Promise<number>;
+    fetchFullObjectsMatchingKeysOnlyIndexQuery<T>(qry: DocQueryCommandInput, keyNames: string[], batchSize?: number): Promise<T[]>;
+    fetchAllInBatches<T>(tableName: string, inKeys: any[], batchSize: number): Promise<T[]>;
+    deleteAllInBatches(tableName: string, keys: any[], batchSize: number): Promise<number>;
+    simplePut(tableName: string, value: any, autoRetryCount?: number): Promise<PutItemOutput>;
+    simplePutOnlyIfFieldIsNullOrUndefined(tableName: string, value: any, fieldName: string): Promise<boolean>;
+    simplePutWithCollisionAvoidance<T>(tableName: string, value: T, keyNames: string[], adjustFunction: (val: T) => T, maxAdjusts?: number, autoRetryCount?: number): Promise<T>;
+    simpleGet<T>(tableName: string, keys: any, autoRetryCount?: number): Promise<T>;
+    simpleGetWithCounterDecrement<T>(tableName: string, keys: any, counterAttributeName: string, deleteOnZero: boolean, autoRetryCount?: number): Promise<T>;
+    simpleDelete(tableName: string, keys: any): Promise<DeleteItemCommandOutput>;
+    atomicCounter(tableName: string, keys: any, counterFieldName: string, increment?: number): Promise<number>;
+}

package/dist/types/dynamodb/dynamo-ratchet.d.ts

@@ -0,0 +1,36 @@
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import { DynamoCountResult } from '../model/dynamo-count-result';
+import { DynamoRatchetLike } from './dynamo-ratchet-like';
+import { DeleteItemCommandOutput, PutItemCommandOutput, QueryCommandOutput, ScanCommandOutput } from '@aws-sdk/client-dynamodb';
+import { DocScanCommandInput } from '../model/dynamo/doc-scan-command-input';
+import { DocQueryCommandInput } from '../model/dynamo/doc-query-command-input';
+export declare class DynamoRatchet implements DynamoRatchetLike {
+    private awsDDB;
+    constructor(awsDDB: DynamoDBDocumentClient);
+    getDDB(): DynamoDBDocumentClient;
+    tableIsEmpty(tableName: string): Promise<boolean>;
+    scanPromise(input: DocScanCommandInput): Promise<ScanCommandOutput>;
+    queryPromise(input: DocQueryCommandInput): Promise<QueryCommandOutput>;
+    throughputSafeScanOrQuery<T, R>(proc: (T: any) => Promise<R>, input: T, maxTries?: number, inCurrentTry?: number): Promise<R>;
+    fullyExecuteQueryCount(qry: DocQueryCommandInput, delayMS?: number): Promise<DynamoCountResult>;
+    fullyExecuteQuery<T>(qry: DocQueryCommandInput, delayMS?: number, softLimit?: number): Promise<T[]>;
+    fullyExecuteProcessOverQuery<T>(qry: DocQueryCommandInput, proc: (val: T) => Promise<void>, delayMS?: number, softLimit?: number): Promise<number>;
+    fullyExecuteScanCount(scan: DocScanCommandInput, delayMS?: number): Promise<DynamoCountResult>;
+    fullyExecuteScan<T>(scan: DocScanCommandInput, delayMS?: number, softLimit?: number): Promise<T[]>;
+    fullyExecuteProcessOverScan<T>(scan: DocScanCommandInput, proc: (val: T) => Promise<void>, delayMS?: number, softLimit?: number): Promise<number>;
+    writeAllInBatches<T>(tableName: string, elements: T[], batchSize: number): Promise<number>;
+    fetchFullObjectsMatchingKeysOnlyIndexQuery<T>(qry: DocQueryCommandInput, keyNames: string[], batchSize?: number): Promise<T[]>;
+    fetchAllInBatches<T>(tableName: string, inKeys: Record<string, any>[], batchSize: number): Promise<T[]>;
+    deleteAllInBatches(tableName: string, keys: Record<string, any>[], batchSize: number): Promise<number>;
+    simplePut(tableName: string, value: Record<string, any>, autoRetryCount?: number): Promise<PutItemCommandOutput>;
+    simplePutOnlyIfFieldIsNullOrUndefined(tableName: string, value: Record<string, any>, fieldName: string): Promise<boolean>;
+    simplePutWithCollisionAvoidance<T>(tableName: string, value: T, keyNames: string[], adjustFunction: (val: T) => T, maxAdjusts?: number, autoRetryCount?: number): Promise<T>;
+    simpleGet<T>(tableName: string, keys: Record<string, any>, autoRetryCount?: number): Promise<T>;
+    static objectIsErrorWithProvisionedThroughputExceededExceptionCode(err: Record<string, any>): boolean;
+    simpleGetWithCounterDecrement<T>(tableName: string, keys: Record<string, any>, counterAttributeName: string, deleteOnZero: boolean, autoRetryCount?: number): Promise<T>;
+    simpleDelete(tableName: string, keys: Record<string, any>): Promise<DeleteItemCommandOutput>;
+    atomicCounter(tableName: string, keys: Record<string, any>, counterFieldName: string, increment?: number): Promise<number>;
+    static cleanObject(ob: Record<string, any>): void;
+    static stripToKeysOnly(input: Record<string, any>, keysNames: string[]): Record<string, any>;
+    static stripAllToKeysOnly(input: Record<string, any>[], keys: string[]): Record<string, any>[];
+}

package/dist/types/dynamodb/dynamo-table-ratchet.d.ts

@@ -0,0 +1,11 @@
+import { CreateTableCommandInput, CreateTableCommandOutput, DeleteTableCommandOutput, DescribeTableCommandOutput, DynamoDBClient } from '@aws-sdk/client-dynamodb';
+export declare class DynamoTableRatchet {
+    private awsDDB;
+    constructor(awsDDB: DynamoDBClient);
+    deleteTable(tableName: string, waitForDelete?: boolean): Promise<DeleteTableCommandOutput>;
+    createTable(input: CreateTableCommandInput, waitForReady?: boolean, replaceIfExists?: boolean): Promise<CreateTableCommandOutput>;
+    waitForTableReady(tableName: string): Promise<boolean>;
+    waitForTableDelete(tableName: string): Promise<void>;
+    tableExists(tableName: string): Promise<boolean>;
+    safeDescribeTable(tableName: string): Promise<DescribeTableCommandOutput>;
+}

package/dist/types/dynamodb/hash-spreader.d.ts

@@ -0,0 +1,15 @@
+export declare class HashSpreader {
+    private spots;
+    private buckets;
+    private separator;
+    private alphabet;
+    private _allSlots;
+    constructor(spots?: number, buckets?: number, separator?: string, alphabet?: string);
+    get allBuckets(): string[];
+    get randomBucket(): string;
+    allSpreadValues(input: string): string[];
+    allSpreadValuesForArray(inputs: string[]): string[];
+    addSpreader(input: string): string;
+    extractBucket(input: string): string;
+    removeBucket(input: string): string;
+}

package/dist/types/ec2/ec2-ratchet.d.ts

@@ -0,0 +1,25 @@
+import { Instance } from '@aws-sdk/client-ec2';
+import { SendSSHPublicKeyCommandOutput } from '@aws-sdk/client-ec2-instance-connect';
+/**
+ * Service to simplify interacting with EC2 instances
+ *
+ * NOTE!  If you are going to describe instances, you MUST use resource: '*' in your
+ * IAM priv - any other value will fail.  See
+ * https://forums.aws.amazon.com/thread.jspa?threadID=142312 and
+ * https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html
+ *
+ *
+ * Really should combine start and stop below
+ */
+export declare class Ec2Ratchet {
+    private region;
+    private availabilityZone;
+    private ec2;
+    private ec2InstanceConnect;
+    constructor(region?: string, availabilityZone?: string);
+    stopInstance(instanceId: string, maxWaitForShutdownMS?: number): Promise<boolean>;
+    launchInstance(instanceId: string, maxWaitForStartupMS?: number): Promise<boolean>;
+    describeInstance(instanceId: string): Promise<Instance>;
+    listAllInstances(instanceIds?: string[]): Promise<Instance[]>;
+    sendPublicKeyToEc2Instance(instanceId: string, publicKeyString: string, instanceOsUser?: string): Promise<SendSSHPublicKeyCommandOutput>;
+}

package/dist/types/environment/cascade-environment-service-provider.d.ts

@@ -0,0 +1,9 @@
+import { EnvironmentServiceProvider } from './environment-service-provider';
+/**
+ * Reads a series of providers, returning the first non-null, non-error
+ */
+export declare class CascadeEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+    private providers;
+    constructor(providers: EnvironmentServiceProvider<T>[]);
+    fetchConfig(name: string): Promise<T>;
+}

package/dist/types/environment/env-var-environment-service-provider.d.ts

@@ -0,0 +1,10 @@
+import { EnvironmentServiceProvider } from './environment-service-provider';
+/**
+ * Service for reading environmental variables
+ * Also hides the decryption detail from higher up servicess
+ */
+export declare class EnvVarEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+    private envVarName;
+    constructor(envVarName: string);
+    fetchConfig(): Promise<T>;
+}

package/dist/types/environment/environment-service-config.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Configuration of environmental server
+ */
+export interface EnvironmentServiceConfig {
+    maxRetries: number;
+    backoffMultiplierMS: number;
+}

package/dist/types/environment/environment-service-provider.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Classes implementing EnvironmentServiceProvider offer the ability to fetch a configuration
+ * object from _somewhere_
+ */
+export interface EnvironmentServiceProvider<T> {
+    fetchConfig(name: string): Promise<T>;
+}

package/dist/types/environment/environment-service.d.ts

@@ -0,0 +1,14 @@
+import { EnvironmentServiceProvider } from './environment-service-provider';
+import { EnvironmentServiceConfig } from './environment-service-config';
+/**
+ * Wraps up a EnvironmentServiceProvider and provides caching and retry-on-failure logic
+ */
+export declare class EnvironmentService<T> {
+    private provider;
+    private cfg;
+    private readPromiseCache;
+    static defaultEnvironmentServiceConfig(): EnvironmentServiceConfig;
+    constructor(provider: EnvironmentServiceProvider<T>, cfg?: EnvironmentServiceConfig);
+    getConfig(name: string): Promise<T>;
+    private getConfigUncached;
+}

package/dist/types/environment/fixed-environment-service-provider.d.ts

@@ -0,0 +1,10 @@
+import { EnvironmentServiceProvider } from './environment-service-provider';
+/**
+ * Forces in a single object as the environment
+ */
+export declare class FixedEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+    private value;
+    constructor(value: Map<string, T>);
+    static fromRecord<T>(record: Record<string, T>): FixedEnvironmentServiceProvider<T>;
+    fetchConfig(name: string): Promise<T>;
+}

package/dist/types/environment/s3-environment-service-provider.d.ts

@@ -0,0 +1,18 @@
+import { EnvironmentServiceProvider } from './environment-service-provider';
+import { S3Client } from '@aws-sdk/client-s3';
+/**
+ * Service for reading environmental variables from S3
+ */
+export declare class S3EnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+    private cfg;
+    private ratchet;
+    constructor(cfg: S3EnvironmentServiceProviderConfig);
+    fetchConfig(name: string): Promise<T>;
+}
+export interface S3EnvironmentServiceProviderConfig {
+    s3Override?: S3Client;
+    bucketName: string;
+    region?: string;
+    pathPrefix?: string;
+    pathSuffix?: string;
+}

package/dist/types/environment/ssm-environment-service-provider.d.ts

@@ -0,0 +1,12 @@
+import { EnvironmentServiceProvider } from './environment-service-provider';
+/**
+ * Service for reading environmental variables
+ * Also hides the decryption detail from higher up services
+ */
+export declare class SsmEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+    private region;
+    private ssmEncrypted;
+    private ssm;
+    constructor(region?: string, ssmEncrypted?: boolean);
+    fetchConfig(name: string): Promise<T>;
+}

package/dist/types/expiring-code/dynamo-expiring-code-provider.d.ts

@@ -0,0 +1,12 @@
+import { ExpiringCodeProvider } from './expiring-code-provider';
+import { DynamoRatchet } from '../dynamodb/dynamo-ratchet';
+import { ExpiringCode } from './expiring-code';
+import { DynamoTableRatchet } from '../dynamodb/dynamo-table-ratchet';
+export declare class DynamoExpiringCodeProvider implements ExpiringCodeProvider {
+    private tableName;
+    private dynamoRatchet;
+    constructor(tableName: string, dynamoRatchet: DynamoRatchet);
+    checkCode(code: string, context: string, deleteOnMatch?: boolean): Promise<boolean>;
+    storeCode(code: ExpiringCode): Promise<boolean>;
+    createTableIfMissing(dtr: DynamoTableRatchet): Promise<any>;
+}

package/dist/types/expiring-code/expiring-code-params.d.ts

@@ -0,0 +1,7 @@
+export interface ExpiringCodeParams {
+    context: string;
+    timeToLiveSeconds: number;
+    tags?: string[];
+    length: number;
+    alphabet: string;
+}

package/dist/types/expiring-code/expiring-code-provider.d.ts

@@ -0,0 +1,5 @@
+import { ExpiringCode } from './expiring-code';
+export interface ExpiringCodeProvider {
+    storeCode(code: ExpiringCode): Promise<boolean>;
+    checkCode(code: string, context: string, deleteOnMatch?: boolean): Promise<boolean>;
+}

package/dist/types/expiring-code/expiring-code-ratchet.d.ts

@@ -0,0 +1,13 @@
+import { ExpiringCodeProvider } from './expiring-code-provider';
+import { ExpiringCodeParams } from './expiring-code-params';
+import { ExpiringCode } from './expiring-code';
+/**
+ * Supports creating and checking single use codes
+ */
+export declare class ExpiringCodeRatchet {
+    private provider;
+    constructor(provider: ExpiringCodeProvider);
+    static generateCode(params: ExpiringCodeParams): ExpiringCode;
+    createNewCode(params: ExpiringCodeParams): Promise<ExpiringCode>;
+    checkCode(code: string, context: string, deleteOnMatch?: boolean): Promise<boolean>;
+}

package/dist/types/expiring-code/expiring-code.d.ts

@@ -0,0 +1,6 @@
+export interface ExpiringCode {
+    code: string;
+    context: string;
+    expiresEpochMS: number;
+    tags?: string[];
+}