@d0v3riz/baileys 6.3.0

package/lib/Types/Message.d.ts

@@ -0,0 +1,245 @@
+/// <reference types="node" />
+import { AxiosRequestConfig } from 'axios';
+import type { Logger } from 'pino';
+import type { Readable } from 'stream';
+import type { URL } from 'url';
+import { proto } from '../../WAProto';
+import { MEDIA_HKDF_KEY_MAPPING } from '../Defaults';
+import type { GroupMetadata } from './GroupMetadata';
+import { CacheStore } from './Socket';
+export { proto as WAProto };
+export declare type WAMessage = proto.IWebMessageInfo;
+export declare type WAMessageContent = proto.IMessage;
+export declare type WAContactMessage = proto.Message.IContactMessage;
+export declare type WAContactsArrayMessage = proto.Message.IContactsArrayMessage;
+export declare type WAMessageKey = proto.IMessageKey;
+export declare type WATextMessage = proto.Message.IExtendedTextMessage;
+export declare type WAContextInfo = proto.IContextInfo;
+export declare type WALocationMessage = proto.Message.ILocationMessage;
+export declare type WAGenericMediaMessage = proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
+export import WAMessageStubType = proto.WebMessageInfo.StubType;
+export import WAMessageStatus = proto.WebMessageInfo.Status;
+export declare type WAMediaUpload = Buffer | {
+    url: URL | string;
+} | {
+    stream: Readable;
+};
+/** Set of message types that are supported by the library */
+export declare type MessageType = keyof proto.Message;
+export declare type DownloadableMessage = {
+    mediaKey?: Uint8Array | null;
+    directPath?: string | null;
+    url?: string | null;
+};
+export declare type MessageReceiptType = 'read' | 'read-self' | 'hist_sync' | 'peer_msg' | 'sender' | 'inactive' | 'played' | undefined;
+export declare type MediaConnInfo = {
+    auth: string;
+    ttl: number;
+    hosts: {
+        hostname: string;
+        maxContentLengthBytes: number;
+    }[];
+    fetchDate: Date;
+};
+export interface WAUrlInfo {
+    'canonical-url': string;
+    'matched-text': string;
+    title: string;
+    description?: string;
+    jpegThumbnail?: Buffer;
+    highQualityThumbnail?: proto.Message.IImageMessage;
+    originalThumbnailUrl?: string;
+}
+declare type Mentionable = {
+    /** list of jids that are mentioned in the accompanying text */
+    mentions?: string[];
+};
+declare type Contextable = {
+    /** add contextInfo to the message */
+    contextInfo?: proto.IContextInfo;
+};
+declare type ViewOnce = {
+    viewOnce?: boolean;
+};
+declare type Buttonable = {
+    /** add buttons to the message  */
+    buttons?: proto.Message.ButtonsMessage.IButton[];
+};
+declare type Templatable = {
+    /** add buttons to the message (conflicts with normal buttons)*/
+    templateButtons?: proto.IHydratedTemplateButton[];
+    footer?: string;
+};
+declare type Editable = {
+    edit?: WAMessageKey;
+};
+declare type Listable = {
+    /** Sections of the List */
+    sections?: proto.Message.ListMessage.ISection[];
+    /** Title of a List Message only */
+    title?: string;
+    /** Text of the bnutton on the list (required) */
+    buttonText?: string;
+};
+declare type WithDimensions = {
+    width?: number;
+    height?: number;
+};
+export declare type PollMessageOptions = {
+    name: string;
+    selectableCount?: number;
+    values: string[];
+    /** 32 byte message secret to encrypt poll selections */
+    messageSecret?: Uint8Array;
+};
+export declare type MediaType = keyof typeof MEDIA_HKDF_KEY_MAPPING;
+export declare type AnyMediaMessageContent = (({
+    image: WAMediaUpload;
+    caption?: string;
+    jpegThumbnail?: string;
+} & Mentionable & Contextable & Buttonable & Templatable & WithDimensions) | ({
+    video: WAMediaUpload;
+    caption?: string;
+    gifPlayback?: boolean;
+    jpegThumbnail?: string;
+} & Mentionable & Contextable & Buttonable & Templatable & WithDimensions) | {
+    audio: WAMediaUpload;
+    /** if set to true, will send as a `voice note` */
+    ptt?: boolean;
+    /** optionally tell the duration of the audio */
+    seconds?: number;
+} | ({
+    sticker: WAMediaUpload;
+    isAnimated?: boolean;
+} & WithDimensions) | ({
+    document: WAMediaUpload;
+    mimetype: string;
+    fileName?: string;
+    caption?: string;
+} & Contextable & Buttonable & Templatable)) & {
+    mimetype?: string;
+} & Editable;
+export declare type ButtonReplyInfo = {
+    displayText: string;
+    id: string;
+    index: number;
+};
+export declare type WASendableProduct = Omit<proto.Message.ProductMessage.IProductSnapshot, 'productImage'> & {
+    productImage: WAMediaUpload;
+};
+export declare type AnyRegularMessageContent = (({
+    text: string;
+    linkPreview?: WAUrlInfo | null;
+} & Mentionable & Contextable & Buttonable & Templatable & Listable & Editable) | AnyMediaMessageContent | ({
+    poll: PollMessageOptions;
+} & Mentionable & Contextable & Buttonable & Templatable & Editable) | {
+    contacts: {
+        displayName?: string;
+        contacts: proto.Message.IContactMessage[];
+    };
+} | {
+    location: WALocationMessage;
+} | {
+    react: proto.Message.IReactionMessage;
+} | {
+    buttonReply: ButtonReplyInfo;
+    type: 'template' | 'plain';
+} | {
+    listReply: Omit<proto.Message.IListResponseMessage, 'contextInfo'>;
+} | {
+    product: WASendableProduct;
+    businessOwnerJid?: string;
+    body?: string;
+    footer?: string;
+}) & ViewOnce;
+export declare type AnyMessageContent = AnyRegularMessageContent | {
+    forward: WAMessage;
+    force?: boolean;
+} | {
+    /** Delete your message or anyone's message in a group (admin required) */
+    delete: WAMessageKey;
+} | {
+    disappearingMessagesInChat: boolean | number;
+};
+export declare type GroupMetadataParticipants = Pick<GroupMetadata, 'participants'>;
+declare type MinimalRelayOptions = {
+    /** override the message ID with a custom provided string */
+    messageId?: string;
+    /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
+    cachedGroupMetadata?: (jid: string) => Promise<GroupMetadataParticipants | undefined>;
+};
+export declare type MessageRelayOptions = MinimalRelayOptions & {
+    /** only send to a specific participant; used when a message decryption fails for a single user */
+    participant?: {
+        jid: string;
+        count: number;
+    };
+    /** additional attributes to add to the WA binary node */
+    additionalAttributes?: {
+        [_: string]: string;
+    };
+    /** should we use the devices cache, or fetch afresh from the server; default assumed to be "true" */
+    useUserDevicesCache?: boolean;
+};
+export declare type MiscMessageGenerationOptions = MinimalRelayOptions & {
+    /** optional, if you want to manually set the timestamp of the message */
+    timestamp?: Date;
+    /** the message you want to quote */
+    quoted?: WAMessage;
+    /** additional contextInfo */
+    contextInfo?: proto.IMessageContextInfo;
+    /** disappearing messages settings */
+    ephemeralExpiration?: number | string;
+    /** timeout for media upload to WA server */
+    mediaUploadTimeoutMs?: number;
+};
+export declare type MessageGenerationOptionsFromContent = MiscMessageGenerationOptions & {
+    userJid: string;
+};
+export declare type WAMediaUploadFunction = (readStream: Readable, opts: {
+    fileEncSha256B64: string;
+    mediaType: MediaType;
+    timeoutMs?: number;
+}) => Promise<{
+    mediaUrl: string;
+    directPath: string;
+}>;
+export declare type MediaGenerationOptions = {
+    logger?: Logger;
+    mediaTypeOverride?: MediaType;
+    upload: WAMediaUploadFunction;
+    /** cache media so it does not have to be uploaded again */
+    mediaCache?: CacheStore;
+    mediaUploadTimeoutMs?: number;
+    options?: AxiosRequestConfig;
+};
+export declare type MessageContentGenerationOptions = MediaGenerationOptions & {
+    getUrlInfo?: (text: string) => Promise<WAUrlInfo | undefined>;
+};
+export declare type MessageGenerationOptions = MessageContentGenerationOptions & MessageGenerationOptionsFromContent;
+/**
+ * Type of message upsert
+ * 1. notify => notify the user, this message was just received
+ * 2. append => append the message to the chat history, no notification required
+ */
+export declare type MessageUpsertType = 'append' | 'notify';
+export declare type MessageUserReceipt = proto.IUserReceipt;
+export declare type WAMessageUpdate = {
+    update: Partial<WAMessage>;
+    key: proto.IMessageKey;
+};
+export declare type WAMessageCursor = {
+    before: WAMessageKey | undefined;
+} | {
+    after: WAMessageKey | undefined;
+};
+export declare type MessageUserReceiptUpdate = {
+    key: proto.IMessageKey;
+    receipt: MessageUserReceipt;
+};
+export declare type MediaDecryptionKeyInfo = {
+    iv: Buffer;
+    cipherKey: Buffer;
+    macKey?: Buffer;
+};
+export declare type MinimalMessage = Pick<proto.IWebMessageInfo, 'key' | 'messageTimestamp'>;

package/lib/Types/Message.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WAMessageStatus = exports.WAMessageStubType = exports.WAProto = void 0;
+const WAProto_1 = require("../../WAProto");
+Object.defineProperty(exports, "WAProto", { enumerable: true, get: function () { return WAProto_1.proto; } });
+// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+exports.WAMessageStubType = WAProto_1.proto.WebMessageInfo.StubType;
+// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+exports.WAMessageStatus = WAProto_1.proto.WebMessageInfo.Status;

package/lib/Types/Product.d.ts

@@ -0,0 +1,78 @@
+import { WAMediaUpload } from './Message';
+export declare type CatalogResult = {
+    data: {
+        paging: {
+            cursors: {
+                before: string;
+                after: string;
+            };
+        };
+        data: any[];
+    };
+};
+export declare type ProductCreateResult = {
+    data: {
+        product: {};
+    };
+};
+export declare type CatalogStatus = {
+    status: string;
+    canAppeal: boolean;
+};
+export declare type CatalogCollection = {
+    id: string;
+    name: string;
+    products: Product[];
+    status: CatalogStatus;
+};
+export declare type ProductAvailability = 'in stock';
+export declare type ProductBase = {
+    name: string;
+    retailerId?: string;
+    url?: string;
+    description: string;
+    price: number;
+    currency: string;
+    isHidden?: boolean;
+};
+export declare type ProductCreate = ProductBase & {
+    /** ISO country code for product origin. Set to undefined for no country */
+    originCountryCode: string | undefined;
+    /** images of the product */
+    images: WAMediaUpload[];
+};
+export declare type ProductUpdate = Omit<ProductCreate, 'originCountryCode'>;
+export declare type Product = ProductBase & {
+    id: string;
+    imageUrls: {
+        [_: string]: string;
+    };
+    reviewStatus: {
+        [_: string]: string;
+    };
+    availability: ProductAvailability;
+};
+export declare type OrderPrice = {
+    currency: string;
+    total: number;
+};
+export declare type OrderProduct = {
+    id: string;
+    imageUrl: string;
+    name: string;
+    quantity: number;
+    currency: string;
+    price: number;
+};
+export declare type OrderDetails = {
+    price: OrderPrice;
+    products: OrderProduct[];
+};
+export declare type CatalogCursor = string;
+export declare type GetCatalogOptions = {
+    /** cursor to start from */
+    cursor?: CatalogCursor;
+    /** number of products to fetch */
+    limit?: number;
+    jid?: string;
+};

package/lib/Types/Product.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/Signal.d.ts

@@ -0,0 +1,57 @@
+import { proto } from '../../WAProto';
+declare type DecryptGroupSignalOpts = {
+    group: string;
+    authorJid: string;
+    msg: Uint8Array;
+};
+declare type ProcessSenderKeyDistributionMessageOpts = {
+    item: proto.Message.ISenderKeyDistributionMessage;
+    authorJid: string;
+};
+declare type DecryptSignalProtoOpts = {
+    jid: string;
+    type: 'pkmsg' | 'msg';
+    ciphertext: Uint8Array;
+};
+declare type EncryptMessageOpts = {
+    jid: string;
+    data: Uint8Array;
+};
+declare type EncryptGroupMessageOpts = {
+    group: string;
+    data: Uint8Array;
+    meId: string;
+};
+declare type PreKey = {
+    keyId: number;
+    publicKey: Uint8Array;
+};
+declare type SignedPreKey = PreKey & {
+    signature: Uint8Array;
+};
+declare type E2ESession = {
+    registrationId: number;
+    identityKey: Uint8Array;
+    signedPreKey: SignedPreKey;
+    preKey: PreKey;
+};
+declare type E2ESessionOpts = {
+    jid: string;
+    session: E2ESession;
+};
+export declare type SignalRepository = {
+    decryptGroupMessage(opts: DecryptGroupSignalOpts): Promise<Uint8Array>;
+    processSenderKeyDistributionMessage(opts: ProcessSenderKeyDistributionMessageOpts): Promise<void>;
+    decryptMessage(opts: DecryptSignalProtoOpts): Promise<Uint8Array>;
+    encryptMessage(opts: EncryptMessageOpts): Promise<{
+        type: 'pkmsg' | 'msg';
+        ciphertext: Uint8Array;
+    }>;
+    encryptGroupMessage(opts: EncryptGroupMessageOpts): Promise<{
+        senderKeyDistributionMessage: Uint8Array;
+        ciphertext: Uint8Array;
+    }>;
+    injectE2ESession(opts: E2ESessionOpts): Promise<void>;
+    jidToSignalProtocolAddress(jid: string): string;
+};
+export {};

package/lib/Types/Signal.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/Socket.d.ts

@@ -0,0 +1,106 @@
+/// <reference types="node" />
+import { AxiosRequestConfig } from 'axios';
+import type { Agent } from 'https';
+import type { Logger } from 'pino';
+import type { URL } from 'url';
+import { proto } from '../../WAProto';
+import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth';
+import { MediaConnInfo } from './Message';
+import { SignalRepository } from './Signal';
+export declare type WAVersion = [number, number, number];
+export declare type WABrowserDescription = [string, string, string];
+export declare type CacheStore = {
+    /** get a cached key and change the stats */
+    get<T>(key: string): T | undefined;
+    /** set a key in the cache */
+    set<T>(key: string, value: T): void;
+    /** delete a key from the cache */
+    del(key: string): void;
+    /** flush all data */
+    flushAll(): void;
+};
+export declare type SocketConfig = {
+    /** the WS url to connect to WA */
+    waWebSocketUrl: string | URL;
+    /** Fails the connection if the socket times out in this interval */
+    connectTimeoutMs: number;
+    /** Default timeout for queries, undefined for no timeout */
+    defaultQueryTimeoutMs: number | undefined;
+    /** ping-pong interval for WS connection */
+    keepAliveIntervalMs: number;
+    /** should baileys use the mobile api instead of the multi device api */
+    mobile?: boolean;
+    /** proxy agent */
+    agent?: Agent;
+    /** pino logger */
+    logger: Logger;
+    /** version to connect with */
+    version: WAVersion;
+    /** override browser config */
+    browser: WABrowserDescription;
+    /** agent used for fetch requests -- uploading/downloading media */
+    fetchAgent?: Agent;
+    /** should the QR be printed in the terminal */
+    printQRInTerminal: boolean;
+    /** should events be emitted for actions done by this socket connection */
+    emitOwnEvents: boolean;
+    /** custom upload hosts to upload media to */
+    customUploadHosts: MediaConnInfo['hosts'];
+    /** time to wait between sending new retry requests */
+    retryRequestDelayMs: number;
+    /** time to wait for the generation of the next QR in ms */
+    qrTimeout?: number;
+    /** provide an auth state object to maintain the auth state */
+    auth: AuthenticationState;
+    /** manage history processing with this control; by default will sync up everything */
+    shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean;
+    /** transaction capability options for SignalKeyStore */
+    transactionOpts: TransactionCapabilityOptions;
+    /** marks the client as online whenever the socket successfully connects */
+    markOnlineOnConnect: boolean;
+    /** provide a cache to store media, so does not have to be re-uploaded */
+    mediaCache?: CacheStore;
+    /**
+     * map to store the retry counts for failed messages;
+     * used to determine whether to retry a message or not */
+    msgRetryCounterCache?: CacheStore;
+    /** provide a cache to store a user's device list */
+    userDevicesCache?: CacheStore;
+    /** cache to store call offers */
+    callOfferCache?: CacheStore;
+    /** width for link preview images */
+    linkPreviewImageThumbnailWidth: number;
+    /** Should Baileys ask the phone for full history, will be received async */
+    syncFullHistory: boolean;
+    /** Should baileys fire init queries automatically, default true */
+    fireInitQueries: boolean;
+    /**
+     * generate a high quality link preview,
+     * entails uploading the jpegThumbnail to WA
+     * */
+    generateHighQualityLinkPreview: boolean;
+    /**
+     * Returns if a jid should be ignored,
+     * no event for that jid will be triggered.
+     * Messages from that jid will also not be decrypted
+     * */
+    shouldIgnoreJid: (jid: string) => boolean | undefined;
+    /**
+     * Optionally patch the message before sending out
+     * */
+    patchMessageBeforeSending: (msg: proto.IMessage, recipientJids: string[]) => Promise<proto.IMessage> | proto.IMessage;
+    /** verify app state MACs */
+    appStateMacVerification: {
+        patch: boolean;
+        snapshot: boolean;
+    };
+    /** options for axios */
+    options: AxiosRequestConfig<{}>;
+    /**
+     * fetch a message from your store
+     * implement this so that messages failed to send
+     * (solves the "this message can take a while" issue) can be retried
+     * */
+    getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>;
+    makeSignalRepository: (auth: SignalAuthState) => SignalRepository;
+};

package/lib/Types/Socket.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/State.d.ts

@@ -0,0 +1,27 @@
+import { Contact } from './Contact';
+export declare type WAConnectionState = 'open' | 'connecting' | 'close';
+export declare type ConnectionState = {
+    /** connection is now open, connecting or closed */
+    connection: WAConnectionState;
+    /** the error that caused the connection to close */
+    lastDisconnect?: {
+        error: Error | undefined;
+        date: Date;
+    };
+    /** is this a new login */
+    isNewLogin?: boolean;
+    /** the current QR code */
+    qr?: string;
+    /** has the device received all pending notifications while it was offline */
+    receivedPendingNotifications?: boolean;
+    /** legacy connection options */
+    legacy?: {
+        phoneConnected: boolean;
+        user?: Contact;
+    };
+    /**
+     * if the client is shown as an active, online client.
+     * If this is false, the primary phone and other devices will receive notifs
+     * */
+    isOnline?: boolean;
+};

package/lib/Types/State.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/index.d.ts

@@ -0,0 +1,54 @@
+export * from './Auth';
+export * from './GroupMetadata';
+export * from './Chat';
+export * from './Contact';
+export * from './State';
+export * from './Message';
+export * from './Socket';
+export * from './Events';
+export * from './Product';
+export * from './Call';
+export * from './Signal';
+import { AuthenticationState } from './Auth';
+import { SocketConfig } from './Socket';
+export declare type UserFacingSocketConfig = Partial<SocketConfig> & {
+    auth: AuthenticationState;
+};
+export declare enum DisconnectReason {
+    connectionClosed = 428,
+    connectionLost = 408,
+    connectionReplaced = 440,
+    timedOut = 408,
+    loggedOut = 401,
+    badSession = 500,
+    restartRequired = 515,
+    multideviceMismatch = 411
+}
+export declare type WAInitResponse = {
+    ref: string;
+    ttl: number;
+    status: 200;
+};
+export declare type WABusinessHoursConfig = {
+    day_of_week: string;
+    mode: string;
+    open_time?: number;
+    close_time?: number;
+};
+export declare type WABusinessProfile = {
+    description: string;
+    email: string | undefined;
+    business_hours: {
+        timezone?: string;
+        config?: WABusinessHoursConfig[];
+        business_config?: WABusinessHoursConfig[];
+    };
+    website: string[];
+    category?: string;
+    wid?: string;
+    address?: string;
+};
+export declare type CurveKeyPair = {
+    private: Uint8Array;
+    public: Uint8Array;
+};

package/lib/Types/index.js

@@ -0,0 +1,39 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisconnectReason = void 0;
+__exportStar(require("./Auth"), exports);
+__exportStar(require("./GroupMetadata"), exports);
+__exportStar(require("./Chat"), exports);
+__exportStar(require("./Contact"), exports);
+__exportStar(require("./State"), exports);
+__exportStar(require("./Message"), exports);
+__exportStar(require("./Socket"), exports);
+__exportStar(require("./Events"), exports);
+__exportStar(require("./Product"), exports);
+__exportStar(require("./Call"), exports);
+__exportStar(require("./Signal"), exports);
+var DisconnectReason;
+(function (DisconnectReason) {
+    DisconnectReason[DisconnectReason["connectionClosed"] = 428] = "connectionClosed";
+    DisconnectReason[DisconnectReason["connectionLost"] = 408] = "connectionLost";
+    DisconnectReason[DisconnectReason["connectionReplaced"] = 440] = "connectionReplaced";
+    DisconnectReason[DisconnectReason["timedOut"] = 408] = "timedOut";
+    DisconnectReason[DisconnectReason["loggedOut"] = 401] = "loggedOut";
+    DisconnectReason[DisconnectReason["badSession"] = 500] = "badSession";
+    DisconnectReason[DisconnectReason["restartRequired"] = 515] = "restartRequired";
+    DisconnectReason[DisconnectReason["multideviceMismatch"] = 411] = "multideviceMismatch";
+})(DisconnectReason = exports.DisconnectReason || (exports.DisconnectReason = {}));

package/lib/Utils/auth-utils.d.ts

@@ -0,0 +1,18 @@
+import type { Logger } from 'pino';
+import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types';
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger: Logger, _cache?: CacheStore): SignalKeyStore;
+/**
+ * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
+ * this allows batch read & write operations & improves the performance of the lib
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+export declare const addTransactionCapability: (state: SignalKeyStore, logger: Logger, { maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions) => SignalKeyStoreWithTransaction;
+export declare const initAuthCreds: () => AuthenticationCreds;