idea-aws 4.4.1 → 4.4.3

package/dist/src/cognito.js

@@ -0,0 +1,412 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cognito = void 0;
+const CognitoIP = __importStar(require("@aws-sdk/client-cognito-identity-provider"));
+const idea_toolbox_1 = require("idea-toolbox");
+/**
+ * A wrapper for AWS Cognito.
+ */
+class Cognito {
+    constructor(options = {}) {
+        this.cognito = new CognitoIP.CognitoIdentityProviderClient({ region: options.region });
+    }
+    /**
+     * Change the region in which to find the user pool.
+     * Default: the runner's (e.g. Lambda function) region.
+     */
+    setRegion(region) {
+        // there is no quick way to change the region without re-creating the object
+        this.cognito = new CognitoIP.CognitoIdentityProviderClient({ region });
+    }
+    /**
+     * Get the attributes of the user, from the authorizer claims.
+     * @param claims authorizer claims
+     * @return user's data
+     * @deprecated use idea-toolbox's CognitoUser instead
+     */
+    getUserByClaims(claims) {
+        if (!claims)
+            return null;
+        const user = {};
+        // add any additional cognito attribute available in cognito
+        for (const p in claims)
+            if (p.startsWith('cognito:'))
+                user[p.slice(8)] = claims[p];
+        // map the important attributes with reserved names
+        user.userId = claims.sub;
+        user.email = claims.email;
+        return user;
+    }
+    /**
+     * Map the complex structure returned by Cognito for a user's attributes in a simple key-value object.
+     */
+    mapCognitoUserAttributesAsPlainObject(user) {
+        const userAttributes = {};
+        (user.Attributes ?? user.UserAttributes ?? []).forEach((a) => (userAttributes[a.Name] = a.Value));
+        if (!userAttributes.userId)
+            userAttributes.userId = userAttributes.sub;
+        return userAttributes;
+    }
+    //
+    // ADMIN
+    //
+    /**
+     * Identify a user by its email address, returning its attributes.
+     */
+    async getUserByEmail(email, userPoolId) {
+        const command = new CognitoIP.AdminGetUserCommand({ UserPoolId: userPoolId, Username: email });
+        try {
+            const user = await this.cognito.send(command);
+            return this.mapCognitoUserAttributesAsPlainObject(user);
+        }
+        catch (error) {
+            if (error.name === 'UserNotFoundException')
+                throw new Error('User not found');
+            throw error;
+        }
+    }
+    /**
+     * Identify a user by its userId (sub), returning its attributes.
+     */
+    async getUserBySub(sub, userPoolId) {
+        // as of today, there is no a direct way to find a user by its sub: we need to run a query against the users base
+        const command = new CognitoIP.ListUsersCommand({ UserPoolId: userPoolId, Filter: `sub = "${sub}"`, Limit: 1 });
+        const { Users } = await this.cognito.send(command);
+        if (Users.length < 1)
+            throw new Error('User not found');
+        return this.mapCognitoUserAttributesAsPlainObject(Users[0]);
+    }
+    /**
+     * List all the users of the pool.
+     */
+    async listUsers(userPoolId, options = { users: [] }) {
+        const params = { UserPoolId: userPoolId };
+        if (options.pagination)
+            params.PaginationToken = options.pagination;
+        const { Users, PaginationToken: pagination } = await this.cognito.send(new CognitoIP.ListUsersCommand(params));
+        const users = options.users.concat(Users.map(u => new idea_toolbox_1.CognitoUser(this.mapCognitoUserAttributesAsPlainObject(u))));
+        if (pagination)
+            return await this.listUsers(userPoolId, { pagination, users });
+        else
+            return users;
+    }
+    /**
+     * List all the users of the pool, including the information about the groups they're in.
+     * Note: it's slower than the alternative `getAllUsers`: use it only when needed.
+     */
+    async listUsersWithGroupsDetail(cognitoUserPoolId) {
+        const groups = await this.listGroups(cognitoUserPoolId);
+        const users = [];
+        for (const group of groups) {
+            const usersOfGroup = await this.listUsersInGroup(group.name, cognitoUserPoolId);
+            usersOfGroup.forEach(userInGroup => {
+                const userAlreadyInOutputList = users.find(u => u.userId === userInGroup.userId);
+                if (userAlreadyInOutputList)
+                    userAlreadyInOutputList.groups.push(group.name);
+                else {
+                    userInGroup.groups.push(group.name);
+                    users.push(userInGroup);
+                }
+            });
+        }
+        return users;
+    }
+    /**
+     * Create a new user (by its email) in the pool specified.
+     * @return userId of the new user
+     */
+    async createUser(cognitoUserOrEmail, userPoolId, options = {}) {
+        const email = typeof cognitoUserOrEmail === 'string'
+            ? cognitoUserOrEmail
+            : cognitoUserOrEmail.email;
+        if ((0, idea_toolbox_1.isEmpty)(email, 'email'))
+            throw new Error('INVALID_EMAIL');
+        const UserAttributes = [
+            { Name: 'email', Value: email },
+            { Name: 'email_verified', Value: 'true' }
+        ];
+        if (typeof cognitoUserOrEmail === 'object') {
+            const user = cognitoUserOrEmail;
+            UserAttributes.push({ Name: 'name', Value: user.name });
+            UserAttributes.push({ Name: 'picture', Value: user.picture || '' });
+            Object.keys(user.attributes).forEach(a => UserAttributes.push({ Name: 'custom:'.concat(a), Value: String(user.attributes[a]) }));
+        }
+        const params = { UserPoolId: userPoolId, Username: email, UserAttributes };
+        if (options.skipNotification)
+            params.MessageAction = 'SUPPRESS';
+        if (options.temporaryPassword)
+            params.TemporaryPassword = options.temporaryPassword;
+        const { User } = await this.cognito.send(new CognitoIP.AdminCreateUserCommand(params));
+        const userId = this.mapCognitoUserAttributesAsPlainObject(User).sub;
+        if (!userId)
+            throw new Error('Creation failed');
+        return userId;
+    }
+    /**
+     * Resend the password to a user who never logged in.
+     */
+    async resendPassword(email, userPoolId, options = {}) {
+        if ((0, idea_toolbox_1.isEmpty)(email, 'email'))
+            throw new Error('Invalid email');
+        const params = {
+            UserPoolId: userPoolId,
+            Username: email,
+            MessageAction: 'RESEND'
+        };
+        if (options.temporaryPassword)
+            params.TemporaryPassword = options.temporaryPassword;
+        await this.cognito.send(new CognitoIP.AdminCreateUserCommand(params));
+    }
+    /**
+     * Set a new password for a specific user identified by its email (admin-only).
+     * If not specified, the password is generated randomly, and the user must change it at the first login.
+     */
+    async setPassword(email, userPoolId, options = {}) {
+        if ((0, idea_toolbox_1.isEmpty)(email, 'email'))
+            throw new Error('Invalid email');
+        const RANDOM_PASSWORD_LENGTH = 8;
+        const password = options.password ??
+            Math.random()
+                .toString(36)
+                .slice(2, 2 + RANDOM_PASSWORD_LENGTH);
+        const params = {
+            UserPoolId: userPoolId,
+            Username: email,
+            Password: password,
+            Permanent: options.permanent
+        };
+        await this.cognito.send(new CognitoIP.AdminSetUserPasswordCommand(params));
+    }
+    /**
+     * Delete a user by its email (username), in the pool specified.
+     */
+    async deleteUser(email, userPoolId) {
+        if ((0, idea_toolbox_1.isEmpty)(email, 'email'))
+            throw new Error('Invalid email');
+        const command = new CognitoIP.AdminDeleteUserCommand({ UserPoolId: userPoolId, Username: email });
+        await this.cognito.send(command);
+    }
+    //
+    // USER
+    //
+    /**
+     * Sign in a user of a specific pool through username and password.
+     */
+    async signIn(email, password, userPoolId, userPoolClientId) {
+        const command = new CognitoIP.AdminInitiateAuthCommand({
+            UserPoolId: userPoolId,
+            ClientId: userPoolClientId,
+            AuthFlow: 'ADMIN_NO_SRP_AUTH',
+            AuthParameters: { USERNAME: email, PASSWORD: password }
+        });
+        const { AuthenticationResult } = await this.cognito.send(command);
+        if (!AuthenticationResult)
+            throw new Error('Sign-in failed');
+        return AuthenticationResult;
+    }
+    /**
+     * Given a username and a refresh token (and pool data), refresh the session and return the new tokens.
+     */
+    async refreshSession(email, refreshToken, userPoolId, userPoolClientId) {
+        const command = new CognitoIP.AdminInitiateAuthCommand({
+            UserPoolId: userPoolId,
+            ClientId: userPoolClientId,
+            AuthFlow: 'REFRESH_TOKEN_AUTH',
+            AuthParameters: { USERNAME: email, REFRESH_TOKEN: refreshToken }
+        });
+        const { AuthenticationResult } = await this.cognito.send(command);
+        if (!AuthenticationResult)
+            throw new Error('Refresh failed');
+        return AuthenticationResult;
+    }
+    /**
+     * Change the email address (== username) associated to a user.
+     */
+    async updateEmail(email, newEmail, userPoolId) {
+        if ((0, idea_toolbox_1.isEmpty)(newEmail, 'email'))
+            throw new Error('Invalid new email');
+        const command = new CognitoIP.AdminUpdateUserAttributesCommand({
+            UserPoolId: userPoolId,
+            Username: email,
+            UserAttributes: [
+                { Name: 'email', Value: newEmail },
+                { Name: 'email_verified', Value: 'true' }
+            ]
+        });
+        await this.cognito.send(command);
+        // sign out the user from all its devices and resolve
+        await this.globalSignOut(newEmail, userPoolId);
+    }
+    /**
+     * Change the password to sign in for a user.
+     */
+    async updatePassword(email, oldPassword, newPassword, userPoolId, userPoolClientId) {
+        if (newPassword.length < 8)
+            throw new Error('Invalid new password');
+        const tokensForPasswordChange = await this.signIn(email, oldPassword, userPoolId, userPoolClientId);
+        const command = new CognitoIP.ChangePasswordCommand({
+            AccessToken: tokensForPasswordChange.AccessToken,
+            PreviousPassword: oldPassword,
+            ProposedPassword: newPassword
+        });
+        await this.cognito.send(command);
+    }
+    /**
+     * Send to a user the instructions to change the password.
+     */
+    async forgotPassword(email, userPoolClientId) {
+        const command = new CognitoIP.ForgotPasswordCommand({ Username: email, ClientId: userPoolClientId });
+        const { CodeDeliveryDetails } = await this.cognito.send(command);
+        return CodeDeliveryDetails;
+    }
+    /**
+     * Complete the flow of a password forgot.
+     */
+    async confirmForgotPassword(email, newPassword, confirmationCode, userPoolClientId) {
+        const command = new CognitoIP.ConfirmForgotPasswordCommand({
+            ClientId: userPoolClientId,
+            Username: email,
+            ConfirmationCode: confirmationCode,
+            Password: newPassword
+        });
+        await this.cognito.send(command);
+    }
+    /**
+     * Update a (Cognito)User's attributes, excluding the attributes that require specific methods.
+     */
+    async updateUser(user, userPoolId) {
+        const UserAttributes = [
+            { Name: 'name', Value: user.name },
+            { Name: 'picture', Value: user.picture ?? '' }
+        ];
+        Object.keys(user.attributes).forEach(customAttribute => UserAttributes.push({
+            Name: 'custom:'.concat(customAttribute),
+            Value: String(user.attributes[customAttribute])
+        }));
+        const command = new CognitoIP.AdminUpdateUserAttributesCommand({
+            UserPoolId: userPoolId,
+            Username: user.email,
+            UserAttributes
+        });
+        await this.cognito.send(command);
+    }
+    /**
+     * Sign out the user from all devices.
+     */
+    async globalSignOut(email, userPoolId) {
+        const command = new CognitoIP.AdminUserGlobalSignOutCommand({ Username: email, UserPoolId: userPoolId });
+        await this.cognito.send(command);
+    }
+    /**
+     * Confirm and conclude a registration, usign a confirmation code.
+     */
+    async confirmSignUp(email, confirmationCode, userPoolClientId) {
+        if (!email)
+            throw new Error('Invalid email');
+        if (!confirmationCode)
+            throw new Error('Invalid confirmation code');
+        if (!userPoolClientId)
+            throw new Error('Invalid client ID');
+        const command = new CognitoIP.ConfirmSignUpCommand({
+            Username: email,
+            ConfirmationCode: confirmationCode,
+            ClientId: userPoolClientId
+        });
+        await this.cognito.send(command);
+    }
+    /**
+     * List the groups of the user pool.
+     */
+    async listGroups(userPoolId, options = { groups: [] }) {
+        const params = { UserPoolId: userPoolId };
+        if (options.pagination)
+            params.NextToken = options.pagination;
+        const res = await this.cognito.send(new CognitoIP.ListGroupsCommand(params));
+        const pagination = res.NextToken;
+        const groups = options.groups.concat(res.Groups.map(g => ({ name: g.GroupName, description: g.Description })));
+        if (pagination)
+            return await this.listGroups(userPoolId, { pagination, groups });
+        else
+            return groups;
+    }
+    /**
+     * Create a new group in the user pool.
+     */
+    async createGroup(groupName, userPoolId) {
+        const command = new CognitoIP.CreateGroupCommand({ GroupName: groupName, UserPoolId: userPoolId });
+        await this.cognito.send(command);
+    }
+    /**
+     * Delete a group from the user pool.
+     */
+    async deleteGroup(groupName, userPoolId) {
+        const command = new CognitoIP.DeleteGroupCommand({ GroupName: groupName, UserPoolId: userPoolId });
+        await this.cognito.send(command);
+    }
+    /**
+     * List the users part of a group in the user pool.
+     */
+    async listUsersInGroup(group, userPoolId, options = { users: [] }) {
+        const params = {
+            UserPoolId: userPoolId,
+            GroupName: group
+        };
+        if (options.pagination)
+            params.NextToken = options.pagination;
+        const res = await this.cognito.send(new CognitoIP.ListUsersInGroupCommand(params));
+        const pagination = res.NextToken;
+        const users = options.users.concat(res.Users.map(u => new idea_toolbox_1.CognitoUser(this.mapCognitoUserAttributesAsPlainObject(u))));
+        if (pagination)
+            return await this.listUsersInGroup(group, userPoolId, { pagination, users });
+        else
+            return users;
+    }
+    /**
+     * Add a user (by email) to a group in the user pool.
+     */
+    async addUserToGroup(email, group, userPoolId) {
+        const user = new idea_toolbox_1.CognitoUser(await this.getUserByEmail(email, userPoolId));
+        const command = new CognitoIP.AdminAddUserToGroupCommand({
+            UserPoolId: userPoolId,
+            GroupName: group,
+            Username: user.userId
+        });
+        await this.cognito.send(command);
+    }
+    /**
+     * Remove a user (by email) from a group in the user pool.
+     */
+    async removeUserFromGroup(email, group, userPoolId) {
+        const user = new idea_toolbox_1.CognitoUser(await this.getUserByEmail(email, userPoolId));
+        const command = new CognitoIP.AdminRemoveUserFromGroupCommand({
+            UserPoolId: userPoolId,
+            GroupName: group,
+            Username: user.userId
+        });
+        await this.cognito.send(command);
+    }
+}
+exports.Cognito = Cognito;

package/dist/src/comprehend.d.ts

@@ -0,0 +1,34 @@
+import * as AmazonComprehend from '@aws-sdk/client-comprehend';
+import { Sentiment } from 'idea-toolbox';
+/**
+ * A wrapper for Amazon Comprehend.
+ */
+export declare class Comprehend {
+    protected comprehend: AmazonComprehend.ComprehendClient;
+    constructor(options?: {
+        region?: string;
+    });
+    /**
+     * Inspects text and returns an inference of the prevailing sentiment (POSITIVE, NEUTRAL, MIXED, or NEGATIVE).
+     */
+    detectSentiment(params: DetectSentimentParameters): Promise<Sentiment>;
+    /**
+     * Determines the dominant language of the input text.
+     */
+    detectDominantLanguage(params: {
+        text: string;
+    }): Promise<string>;
+}
+export interface DetectSentimentParameters {
+    /**
+     * The language of the input contents. You can specify any of the primary languages supported by Amazon Comprehend.
+     * All contents must be in the same language. Required.
+     * Valid Values: en | es | fr | de | it | pt | ar | hi | ja | ko | zh | zh-TW
+     */
+    language: string;
+    /**
+     * The text to analyze. Required.
+     * A UTF-8 text string. Each string must contain fewer that 5,000 bytes of UTF-8 encoded characters.
+     */
+    text: string;
+}

package/dist/src/comprehend.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Comprehend = void 0;
+const AmazonComprehend = __importStar(require("@aws-sdk/client-comprehend"));
+/**
+ * A wrapper for Amazon Comprehend.
+ */
+class Comprehend {
+    constructor(options = {}) {
+        this.comprehend = new AmazonComprehend.ComprehendClient({ region: options.region });
+    }
+    /**
+     * Inspects text and returns an inference of the prevailing sentiment (POSITIVE, NEUTRAL, MIXED, or NEGATIVE).
+     */
+    async detectSentiment(params) {
+        if (!params.language || !params.text)
+            throw new Error('Missing some parameters');
+        const command = new AmazonComprehend.DetectSentimentCommand({ LanguageCode: params.language, Text: params.text });
+        const { Sentiment } = await this.comprehend.send(command);
+        return Sentiment;
+    }
+    /**
+     * Determines the dominant language of the input text.
+     */
+    async detectDominantLanguage(params) {
+        if (!params.text)
+            throw new Error('Missing text');
+        const command = new AmazonComprehend.DetectDominantLanguageCommand({ Text: params.text });
+        const { Languages } = await this.comprehend.send(command);
+        if (!Languages.length)
+            throw new Error('Not found');
+        return Languages[0].LanguageCode;
+    }
+}
+exports.Comprehend = Comprehend;

package/dist/src/dynamoDB.d.ts

@@ -0,0 +1,108 @@
+import * as DDB from '@aws-sdk/lib-dynamodb';
+import * as DDBUtils from '@aws-sdk/util-dynamodb';
+import { LambdaLogger } from './lambdaLogger';
+/**
+ * A wrapper for AWS DynamoDB.
+ */
+export declare class DynamoDB {
+    protected dynamo: DDB.DynamoDBDocument;
+    protected logger: LambdaLogger;
+    constructor();
+    /**
+     * Convert a JSON object from DynamoDB format to simple JSON.
+     * @data the data in DynamoDB's original format to convert in plain objects
+     * @options the options to use to convert the data
+     */
+    unmarshall(data: Record<string, any>, options?: DDBUtils.unmarshallOptions): Record<string, any>;
+    /**
+     * Returns an IUNID: IDEA's Unique Nano IDentifier, which is an id unique through an IDEA's AWS account and region.
+     * Note: no need of an auth check for external uses: the permissions depend from the context in which it's executed.
+     * @param project project code
+     * @return the IUNID
+     */
+    IUNID(project: string): Promise<string>;
+    protected IUNIDHelper(project: string, attempt: number, maxAttempts: number): Promise<string>;
+    /**
+     * Manage atomic counters (atomic autoincrement values) in IDEA's projects.
+     * They key of an atomic counter should be composed as the following: `DynamoDBTableName_uniqueKey`.
+     * @param key the key of the counter
+     */
+    getAtomicCounterByKey(key: string): Promise<number>;
+    /**
+     * Get an item of a DynamoDB table.
+     * @param params the params to apply to DynamoDB's function
+     */
+    get(params: DDB.GetCommandInput): Promise<any>;
+    /**
+     * Put an item in a DynamoDB table.
+     * @param params the params to apply to DynamoDB's function
+     */
+    put(params: DDB.PutCommandInput): Promise<DDB.PutCommandOutput>;
+    /**
+     * Update an item of a DynamoDB table.
+     * @param params the params to apply to DynamoDB's function
+     */
+    update(params: DDB.UpdateCommandInput): Promise<DDB.UpdateCommandOutput>;
+    /**
+     * Delete an item of a DynamoDB table.
+     * @param params the params to apply to DynamoDB's function
+     */
+    delete(params: DDB.DeleteCommandInput): Promise<DDB.DeleteCommandOutput>;
+    /**
+     * Get group of items based on their keys from DynamoDB table, avoiding the limits of DynamoDB's BatchGetItem.
+     * @param table the target DynamoDB table
+     * @param keys the keys of the objects to retrieve
+     * @param ignoreErr if set, ignore the errors and continue the bulk op.
+     */
+    batchGet(table: string, keys: Record<string, any>[], ignoreErr?: boolean): Promise<any[]>;
+    protected batchGetHelper(table: string, keys: Record<string, any>[], resultElements: Record<string, any>[], ignoreErr: boolean, currentChunk?: number, chunkSize?: number): Promise<Record<string, any>[]>;
+    /**
+     * Put an array of items in a DynamoDB table, avoiding the limits of DynamoDB's BatchWriteItem.
+     * In case of errors, it will retry with a random back-off mechanism until the timeout.
+     * Therefore, in case of timeout, there may be some elements written and some not.
+     * @param table the target DynamoDB table
+     * @param items the objects to insert
+     */
+    batchPut(table: string, items: Record<string, any>[]): Promise<void>;
+    /**
+     * Delete an array of items from a DynamoDB table, avoiding the limits of DynamoDB's BatchWriteItem.
+     * In case of errors, it will retry with a random back-off mechanism until the timeout.
+     * Therefore, in case of timeout, there may be some elements deleted and some not.
+     * @param table the target DynamoDB table
+     * @param keys the keys to delete
+     */
+    batchDelete(table: string, keys: Record<string, any>[]): Promise<void>;
+    protected batchWriteHelper(table: string, itemsOrKeys: Record<string, any>[], isPut: boolean, currentChunk?: number, chunkSize?: number): Promise<void>;
+    protected batchWriteChunkWithRetries(table: string, params: DDB.BatchWriteCommandInput): Promise<void>;
+    /**
+     * Query a DynamoDB table, avoiding the limits of DynamoDB's Query.
+     * @param params the params to apply to DynamoDB's function
+     */
+    query(params: DDB.QueryCommandInput): Promise<any[]>;
+    /**
+     * Scan a DynamoDB table, avoiding the limits of DynamoDB's Query.
+     * @param params the params to apply to DynamoDB's function
+     */
+    scan(params: DDB.ScanCommandInput): Promise<any[]>;
+    protected queryScanHelper(params: DDB.QueryCommandInput | DDB.ScanCommandInput, items: Record<string, any>[], isQuery: boolean): Promise<Record<string, any>[]>;
+    /**
+     * Query a DynamoDB table in the traditional way (no pagination or data mapping).
+     * @param params the params to apply to DynamoDB's function
+     */
+    queryClassic(params: DDB.QueryCommandInput): Promise<DDB.QueryCommandOutput>;
+    /**
+     * Scan a DynamoDB table in the traditional way (no pagination or data mapping).
+     * @param params the params to apply to DynamoDB's function
+     */
+    scanClassic(params: DDB.ScanCommandInput): Promise<DDB.ScanCommandOutput>;
+    /**
+     * Execute a series of write operations in a single transaction.
+     * @param ops the operations to execute in the transaction
+     */
+    transactWrites(ops: {
+        ConditionCheck?: any;
+        Put?: any;
+        Delete?: any;
+        Update?: any;
+    }[]): Promise<void>;
+}