@aws-amplify/pubsub 5.5.6-api-v6-models.b3abc9b.0 → 6.0.0

package/lib/utils/ReconnectionMonitor.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("../Providers/constants");
+exports.ReconnectionMonitor = exports.ReconnectEvent = void 0;
+const constants_1 = require("../Providers/constants");
 var ReconnectEvent;
 (function (ReconnectEvent) {
     ReconnectEvent["START_RECONNECT"] = "START_RECONNECT";
@@ -12,31 +13,30 @@ var ReconnectEvent;
  *   Attempting to reconnect only once creates unrecoverable states when the network state isn't
  *   supported by the browser, so this keeps retrying every minute until halted.
  */
-var ReconnectionMonitor = /** @class */ (function () {
-    function ReconnectionMonitor() {
+class ReconnectionMonitor {
+    constructor() {
         this.reconnectObservers = [];
     }
     /**
      * Add reconnect observer to the list of observers to alert on reconnect
      */
-    ReconnectionMonitor.prototype.addObserver = function (reconnectObserver) {
+    addObserver(reconnectObserver) {
         this.reconnectObservers.push(reconnectObserver);
-    };
+    }
     /**
      * Given a reconnect event, start the appropriate behavior
      */
-    ReconnectionMonitor.prototype.record = function (event) {
-        var _this = this;
+    record(event) {
         if (event === ReconnectEvent.START_RECONNECT) {
             // If the reconnection hasn't been started
             if (this.reconnectSetTimeoutId === undefined &&
                 this.reconnectIntervalId === undefined) {
-                this.reconnectSetTimeoutId = setTimeout(function () {
+                this.reconnectSetTimeoutId = setTimeout(() => {
                     // Reconnect now
-                    _this._triggerReconnect();
+                    this._triggerReconnect();
                     // Retry reconnect every periodically until it works
-                    _this.reconnectIntervalId = setInterval(function () {
-                        _this._triggerReconnect();
+                    this.reconnectIntervalId = setInterval(() => {
+                        this._triggerReconnect();
                     }, constants_1.RECONNECT_INTERVAL);
                 }, constants_1.RECONNECT_DELAY);
             }
@@ -51,23 +51,19 @@ var ReconnectionMonitor = /** @class */ (function () {
                 this.reconnectSetTimeoutId = undefined;
             }
         }
-    };
+    }
     /**
      * Complete all reconnect observers
      */
-    ReconnectionMonitor.prototype.close = function () {
-        this.reconnectObservers.forEach(function (reconnectObserver) {
-            var _a;
-            (_a = reconnectObserver.complete) === null || _a === void 0 ? void 0 : _a.call(reconnectObserver);
+    close() {
+        this.reconnectObservers.forEach(reconnectObserver => {
+            reconnectObserver.complete?.();
         });
-    };
-    ReconnectionMonitor.prototype._triggerReconnect = function () {
-        this.reconnectObservers.forEach(function (reconnectObserver) {
-            var _a;
-            (_a = reconnectObserver.next) === null || _a === void 0 ? void 0 : _a.call(reconnectObserver);
+    }
+    _triggerReconnect() {
+        this.reconnectObservers.forEach(reconnectObserver => {
+            reconnectObserver.next?.();
         });
-    };
-    return ReconnectionMonitor;
-}());
+    }
+}
 exports.ReconnectionMonitor = ReconnectionMonitor;
-//# sourceMappingURL=ReconnectionMonitor.js.map

package/lib-esm/Providers/AWSIot.d.ts

@@ -0,0 +1,10 @@
+import { MqttOverWS, MqttOptions } from './MqttOverWS';
+export interface AWSIoTOptions extends MqttOptions {
+    region?: string;
+    endpoint?: string;
+}
+export declare class AWSIoT extends MqttOverWS {
+    constructor(options?: AWSIoTOptions);
+    protected get region(): string | undefined;
+    protected get endpoint(): Promise<string>;
+}

package/lib-esm/Providers/AWSIot.js

@@ -0,0 +1,30 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { MqttOverWS } from './MqttOverWS';
+import { Signer } from '@aws-amplify/core/internals/utils';
+import { fetchAuthSession } from '@aws-amplify/core';
+const SERVICE_NAME = 'iotdevicegateway';
+export class AWSIoT extends MqttOverWS {
+    constructor(options = {}) {
+        super(options);
+    }
+    get region() {
+        return this.options?.region;
+    }
+    get endpoint() {
+        return (async () => {
+            const endpoint = this.options.endpoint;
+            const serviceInfo = {
+                service: SERVICE_NAME,
+                region: this.region,
+            };
+            const session = await fetchAuthSession();
+            if (!session.credentials) {
+                throw new Error('No auth session credentials');
+            }
+            const { accessKeyId: access_key, secretAccessKey: secret_key, sessionToken: session_token, } = session.credentials;
+            const result = Signer.signUrl(endpoint, { access_key, secret_key, session_token }, serviceInfo);
+            return result;
+        })();
+    }
+}

package/lib-esm/Providers/{MqttOverWSProvider.d.ts → MqttOverWS.d.ts}

@@ -1,12 +1,11 @@
-import Observable from 'zen-observable-ts';
-import { AbstractPubSubProvider } from './PubSubProvider';
-import { PubSubContentObserver, PubSubContent } from '../types/PubSub';
-import { ProviderOptions } from '../types/Provider';
+import { Observable } from 'rxjs';
+import { AbstractPubSub } from './PubSub';
+import { PubSubContentObserver, PubSubContent, PubSubOptions, PublishInput, SubscribeInput } from '../types/PubSub';
 export declare function mqttTopicMatch(filter: string, topic: string): boolean;
-export interface MqttProviderOptions extends ProviderOptions {
+export interface MqttOptions extends PubSubOptions {
     clientId?: string;
     url?: string;
-    aws_pubsub_endpoint?: string;
+    endpoint?: string;
 }
 interface PahoClient {
     onMessageArrived: (params: {
@@ -23,36 +22,37 @@ interface PahoClient {
     isConnected: () => boolean;
     subscribe: (topic: string) => void;
     unsubscribe: (topic: string) => void;
-    send(topic: string, message: string): any;
+    send(topic: string, message: string): void;
 }
 declare class ClientsQueue {
     private promises;
-    get(clientId: string, clientFactory?: (input: string) => Promise<PahoClient | undefined>): Promise<PahoClient>;
+    get(clientId: string, clientFactory?: (input: string) => Promise<PahoClient | undefined>): Promise<PahoClient | undefined>;
     get allClients(): string[];
     remove(clientId: string): void;
 }
-export declare class MqttOverWSProvider extends AbstractPubSubProvider<MqttProviderOptions> {
+export declare class MqttOverWS extends AbstractPubSub<MqttOptions> {
     private _clientsQueue;
-    private connectionState;
+    private connectionState?;
     private readonly connectionStateMonitor;
     private readonly reconnectionMonitor;
-    constructor(options?: MqttProviderOptions);
+    constructor(options?: MqttOptions);
     protected get clientId(): string;
     protected get endpoint(): Promise<string | undefined>;
     protected get clientsQueue(): ClientsQueue;
     protected get isSSLEnabled(): boolean;
-    getProviderName(): string;
     onDisconnect({ clientId, errorCode, ...args }: {
         clientId?: string;
         errorCode?: number;
     }): void;
-    newClient({ url, clientId, }: MqttProviderOptions): Promise<PahoClient>;
-    protected connect(clientId: string, options?: MqttProviderOptions): Promise<PahoClient | undefined>;
+    newClient({ url, clientId }: MqttOptions): Promise<PahoClient>;
+    protected connect(clientId: string, options?: MqttOptions): Promise<PahoClient | undefined>;
     protected disconnect(clientId: string): Promise<void>;
-    publish(topics: string[] | string, msg: PubSubContent): Promise<void>;
+    publish({ topics, message }: PublishInput): Promise<void>;
     protected _topicObservers: Map<string, Set<PubSubContentObserver>>;
     protected _clientIdObservers: Map<string, Set<PubSubContentObserver>>;
     private _onMessage;
-    subscribe(topics: string[] | string, options?: MqttProviderOptions): Observable<PubSubContent>;
+    subscribe({ topics, options, }: SubscribeInput & {
+        options?: MqttOptions;
+    }): Observable<PubSubContent>;
 }
 export {};

package/lib-esm/Providers/MqttOverWS.js

@@ -0,0 +1,268 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// @ts-ignore
+import * as Paho from '../vendor/paho-mqtt';
+import { Observable } from 'rxjs';
+import { AbstractPubSub } from './PubSub';
+import { ConnectionState, } from '../types/PubSub';
+import { Hub, ConsoleLogger as Logger } from '@aws-amplify/core';
+import { amplifyUuid } from '@aws-amplify/core/internals/utils';
+import { ConnectionStateMonitor, CONNECTION_CHANGE, } from '../utils/ConnectionStateMonitor';
+import { ReconnectEvent, ReconnectionMonitor, } from '../utils/ReconnectionMonitor';
+import { AMPLIFY_SYMBOL, CONNECTION_STATE_CHANGE } from './constants';
+const logger = new Logger('MqttOverWS');
+export function mqttTopicMatch(filter, topic) {
+    const filterArray = filter.split('/');
+    const length = filterArray.length;
+    const topicArray = topic.split('/');
+    for (let i = 0; i < length; ++i) {
+        const left = filterArray[i];
+        const right = topicArray[i];
+        if (left === '#')
+            return topicArray.length >= length;
+        if (left !== '+' && left !== right)
+            return false;
+    }
+    return length === topicArray.length;
+}
+class ClientsQueue {
+    constructor() {
+        this.promises = new Map();
+    }
+    async get(clientId, clientFactory) {
+        const cachedPromise = this.promises.get(clientId);
+        if (cachedPromise)
+            return cachedPromise;
+        if (clientFactory) {
+            const newPromise = clientFactory(clientId);
+            this.promises.set(clientId, newPromise);
+            newPromise.catch(() => this.promises.delete(clientId));
+            return newPromise;
+        }
+        return undefined;
+    }
+    get allClients() {
+        return Array.from(this.promises.keys());
+    }
+    remove(clientId) {
+        this.promises.delete(clientId);
+    }
+}
+const dispatchPubSubEvent = (payload) => {
+    Hub.dispatch('pubsub', payload, 'PubSub', AMPLIFY_SYMBOL);
+};
+const topicSymbol = typeof Symbol !== 'undefined' ? Symbol('topic') : '@@topic';
+export class MqttOverWS extends AbstractPubSub {
+    constructor(options = {}) {
+        super({ ...options, clientId: options.clientId || amplifyUuid() });
+        this._clientsQueue = new ClientsQueue();
+        this.connectionStateMonitor = new ConnectionStateMonitor();
+        this.reconnectionMonitor = new ReconnectionMonitor();
+        this._topicObservers = new Map();
+        this._clientIdObservers = new Map();
+        // Monitor the connection health state and pass changes along to Hub
+        this.connectionStateMonitor.connectionStateObservable.subscribe(connectionStateChange => {
+            dispatchPubSubEvent({
+                event: CONNECTION_STATE_CHANGE,
+                data: {
+                    provider: this,
+                    connectionState: connectionStateChange,
+                },
+                message: `Connection state is ${connectionStateChange}`,
+            });
+            this.connectionState = connectionStateChange;
+            // Trigger reconnection when the connection is disrupted
+            if (connectionStateChange === ConnectionState.ConnectionDisrupted) {
+                this.reconnectionMonitor.record(ReconnectEvent.START_RECONNECT);
+            }
+            else if (connectionStateChange !== ConnectionState.Connecting) {
+                // Trigger connected to halt reconnection attempts
+                this.reconnectionMonitor.record(ReconnectEvent.HALT_RECONNECT);
+            }
+        });
+    }
+    get clientId() {
+        return this.options.clientId;
+    }
+    get endpoint() {
+        return Promise.resolve(this.options.endpoint);
+    }
+    get clientsQueue() {
+        return this._clientsQueue;
+    }
+    get isSSLEnabled() {
+        return !this.options['aws_appsync_dangerously_connect_to_http_endpoint_for_testing'];
+    }
+    onDisconnect({ clientId, errorCode, ...args }) {
+        if (errorCode !== 0) {
+            logger.warn(clientId, JSON.stringify({ errorCode, ...args }, null, 2));
+            if (!clientId) {
+                return;
+            }
+            const clientIdObservers = this._clientIdObservers.get(clientId);
+            if (!clientIdObservers) {
+                return;
+            }
+            this.disconnect(clientId);
+        }
+    }
+    async newClient({ url, clientId }) {
+        logger.debug('Creating new MQTT client', clientId);
+        this.connectionStateMonitor.record(CONNECTION_CHANGE.OPENING_CONNECTION);
+        // @ts-ignore
+        const client = new Paho.Client(url, clientId);
+        client.onMessageArrived = ({ destinationName: topic, payloadString: msg, }) => {
+            this._onMessage(topic, msg);
+        };
+        client.onConnectionLost = ({ errorCode, ...args }) => {
+            this.onDisconnect({ clientId, errorCode, ...args });
+            this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
+        };
+        const connected = await new Promise((resolve, reject) => {
+            client.connect({
+                useSSL: this.isSSLEnabled,
+                mqttVersion: 3,
+                onSuccess: () => resolve(true),
+                onFailure: () => {
+                    if (clientId)
+                        this._clientsQueue.remove(clientId);
+                    this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
+                    resolve(false);
+                },
+            });
+        });
+        if (connected) {
+            this.connectionStateMonitor.record(CONNECTION_CHANGE.CONNECTION_ESTABLISHED);
+        }
+        return client;
+    }
+    async connect(clientId, options = {}) {
+        return await this.clientsQueue.get(clientId, async (clientId) => {
+            const client = await this.newClient({ ...options, clientId });
+            if (client) {
+                // Once connected, subscribe to all topics registered observers
+                this._topicObservers.forEach((_value, key) => {
+                    client.subscribe(key);
+                });
+            }
+            return client;
+        });
+    }
+    async disconnect(clientId) {
+        const client = await this.clientsQueue.get(clientId);
+        if (client && client.isConnected()) {
+            client.disconnect();
+        }
+        this.clientsQueue.remove(clientId);
+        this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
+    }
+    async publish({ topics, message }) {
+        const targetTopics = [].concat(topics);
+        const msg = JSON.stringify(message);
+        const client = await this.clientsQueue.get(this.clientId);
+        if (client) {
+            logger.debug('Publishing to topic(s)', targetTopics.join(','), message);
+            targetTopics.forEach(topic => client.send(topic, msg));
+        }
+        else {
+            logger.debug('Publishing to topic(s) failed', targetTopics.join(','), message);
+        }
+    }
+    _onMessage(topic, msg) {
+        try {
+            const matchedTopicObservers = [];
+            this._topicObservers.forEach((observerForTopic, observerTopic) => {
+                if (mqttTopicMatch(observerTopic, topic)) {
+                    matchedTopicObservers.push(observerForTopic);
+                }
+            });
+            const parsedMessage = JSON.parse(msg);
+            if (typeof parsedMessage === 'object') {
+                // @ts-ignore
+                parsedMessage[topicSymbol] = topic;
+            }
+            matchedTopicObservers.forEach(observersForTopic => {
+                observersForTopic.forEach(observer => observer.next(parsedMessage));
+            });
+        }
+        catch (error) {
+            logger.warn('Error handling message', error, msg);
+        }
+    }
+    subscribe({ topics, options = {}, }) {
+        const targetTopics = [].concat(topics);
+        logger.debug('Subscribing to topic(s)', targetTopics.join(','));
+        let reconnectSubscription;
+        return new Observable(observer => {
+            targetTopics.forEach(topic => {
+                // this._topicObservers is used to notify the observers according to the topic received on the message
+                let observersForTopic = this._topicObservers.get(topic);
+                if (!observersForTopic) {
+                    observersForTopic = new Set();
+                    this._topicObservers.set(topic, observersForTopic);
+                }
+                observersForTopic.add(observer);
+            });
+            const { clientId = this.clientId } = options;
+            // this._clientIdObservers is used to close observers when client gets disconnected
+            let observersForClientId = this._clientIdObservers.get(clientId);
+            if (!observersForClientId) {
+                observersForClientId = new Set();
+            }
+            if (observersForClientId) {
+                observersForClientId.add(observer);
+                this._clientIdObservers.set(clientId, observersForClientId);
+            }
+            (async () => {
+                const getClient = async () => {
+                    try {
+                        const { url = await this.endpoint } = options;
+                        const client = await this.connect(clientId, { url });
+                        if (client !== undefined) {
+                            targetTopics.forEach(topic => {
+                                client.subscribe(topic);
+                            });
+                        }
+                    }
+                    catch (e) {
+                        logger.debug('Error forming connection', e);
+                    }
+                };
+                // Establish the initial connection
+                await getClient();
+                // Add an observable to the reconnection list to manage reconnection for this subscription
+                reconnectSubscription = new Observable(observer => {
+                    this.reconnectionMonitor.addObserver(observer);
+                }).subscribe(() => {
+                    getClient();
+                });
+            })();
+            return async () => {
+                const client = await this.clientsQueue.get(clientId);
+                reconnectSubscription?.unsubscribe();
+                if (client) {
+                    this._clientIdObservers.get(clientId)?.delete(observer);
+                    // No more observers per client => client not needed anymore
+                    if (this._clientIdObservers.get(clientId)?.size === 0) {
+                        this.disconnect(clientId);
+                        this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSING_CONNECTION);
+                        this._clientIdObservers.delete(clientId);
+                    }
+                    targetTopics.forEach(topic => {
+                        const observersForTopic = this._topicObservers.get(topic) ||
+                            new Set();
+                        observersForTopic.delete(observer);
+                        // if no observers exists for the topic, topic should be removed
+                        if (observersForTopic.size === 0) {
+                            this._topicObservers.delete(topic);
+                            if (client.isConnected()) {
+                                client.unsubscribe(topic);
+                            }
+                        }
+                    });
+                }
+                return null;
+            };
+        });
+    }
+}

package/lib-esm/Providers/PubSub.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { PubSubBase, PubSubOptions, PubSubContent, PublishInput, SubscribeInput } from '../types/PubSub';
+export declare abstract class AbstractPubSub<T extends PubSubOptions> implements PubSubBase {
+    private _config;
+    constructor(options: T);
+    configure(config: T): T;
+    protected get options(): T;
+    abstract newClient(clientOptions: T): Promise<any>;
+    abstract publish(input: PublishInput): void;
+    abstract subscribe(input: SubscribeInput): Observable<PubSubContent>;
+}

package/lib-esm/Providers/PubSub.js

@@ -0,0 +1,15 @@
+import { ConsoleLogger as Logger } from '@aws-amplify/core';
+const logger = new Logger('AbstractPubSubProvider');
+export class AbstractPubSub {
+    constructor(options) {
+        this._config = options;
+    }
+    configure(config) {
+        this._config = { ...config, ...this._config };
+        logger.debug(`configure`, this._config);
+        return this.options;
+    }
+    get options() {
+        return { ...this._config };
+    }
+}

package/lib-esm/Providers/constants.d.ts

@@ -1,3 +1,4 @@
+export { AMPLIFY_SYMBOL } from '@aws-amplify/core/internals/utils';
 export declare const MAX_DELAY_MS = 5000;
 export declare const NON_RETRYABLE_CODES: number[];
 export declare const CONNECTION_STATE_CHANGE = "ConnectionStateChange";
@@ -63,7 +64,6 @@ export declare enum SOCKET_STATUS {
     READY = 1,
     CONNECTING = 2
 }
-export declare const AMPLIFY_SYMBOL: Symbol;
 export declare const AWS_APPSYNC_REALTIME_HEADERS: {
     accept: string;
     'content-encoding': string;

package/lib-esm/Providers/constants.js

@@ -1,8 +1,9 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export var MAX_DELAY_MS = 5000;
-export var NON_RETRYABLE_CODES = [400, 401, 403];
-export var CONNECTION_STATE_CHANGE = 'ConnectionStateChange';
+export { AMPLIFY_SYMBOL } from '@aws-amplify/core/internals/utils';
+export const MAX_DELAY_MS = 5000;
+export const NON_RETRYABLE_CODES = [400, 401, 403];
+export const CONNECTION_STATE_CHANGE = 'ConnectionStateChange';
 export var MESSAGE_TYPES;
 (function (MESSAGE_TYPES) {
     /**
@@ -68,10 +69,7 @@ export var SOCKET_STATUS;
     SOCKET_STATUS[SOCKET_STATUS["READY"] = 1] = "READY";
     SOCKET_STATUS[SOCKET_STATUS["CONNECTING"] = 2] = "CONNECTING";
 })(SOCKET_STATUS || (SOCKET_STATUS = {}));
-export var AMPLIFY_SYMBOL = (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function'
-    ? Symbol.for('amplify_default')
-    : '@@amplify_default');
-export var AWS_APPSYNC_REALTIME_HEADERS = {
+export const AWS_APPSYNC_REALTIME_HEADERS = {
     accept: 'application/json, text/javascript',
     'content-encoding': 'amz-1.0',
     'content-type': 'application/json; charset=UTF-8',
@@ -79,25 +77,24 @@ export var AWS_APPSYNC_REALTIME_HEADERS = {
 /**
  * Time in milleseconds to wait for GQL_CONNECTION_INIT message
  */
-export var CONNECTION_INIT_TIMEOUT = 15000;
+export const CONNECTION_INIT_TIMEOUT = 15000;
 /**
  * Time in milleseconds to wait for GQL_START_ACK message
  */
-export var START_ACK_TIMEOUT = 15000;
+export const START_ACK_TIMEOUT = 15000;
 /**
  * Default Time in milleseconds to wait for GQL_CONNECTION_KEEP_ALIVE message
  */
-export var DEFAULT_KEEP_ALIVE_TIMEOUT = 5 * 60 * 1000;
+export const DEFAULT_KEEP_ALIVE_TIMEOUT = 5 * 60 * 1000;
 /**
  * Default Time in milleseconds to alert for missed GQL_CONNECTION_KEEP_ALIVE message
  */
-export var DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT = 65 * 1000;
+export const DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT = 65 * 1000;
 /**
  * Default delay time in milleseconds between when reconnect is triggered vs when it is attempted
  */
-export var RECONNECT_DELAY = 5 * 1000;
+export const RECONNECT_DELAY = 5 * 1000;
 /**
  * Default interval time in milleseconds between when reconnect is re-attempted
  */
-export var RECONNECT_INTERVAL = 60 * 1000;
-//# sourceMappingURL=constants.js.map
+export const RECONNECT_INTERVAL = 60 * 1000;

package/lib-esm/Providers/index.d.ts

@@ -1,4 +1,3 @@
-export { AbstractPubSubProvider } from './PubSubProvider';
-export { AWSAppSyncRealTimeProvider, AWSAppSyncRealTimeProviderOptions, ObserverQuery, } from './AWSAppSyncRealTimeProvider';
-export { AWSIoTProvider, AWSIoTProviderOptions } from './AWSIotProvider';
-export { MqttProviderOptions, MqttOverWSProvider, mqttTopicMatch, } from './MqttOverWSProvider';
+export { AbstractPubSub } from './PubSub';
+export { AWSIoT, AWSIoTOptions } from './AWSIot';
+export { MqttOptions, MqttOverWS, mqttTopicMatch } from './MqttOverWS';

package/lib-esm/Providers/index.js

@@ -1,7 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export { AbstractPubSubProvider } from './PubSubProvider';
-export { AWSAppSyncRealTimeProvider, } from './AWSAppSyncRealTimeProvider';
-export { AWSIoTProvider } from './AWSIotProvider';
-export { MqttOverWSProvider, mqttTopicMatch, } from './MqttOverWSProvider';
-//# sourceMappingURL=index.js.map
+export { AbstractPubSub } from './PubSub';
+export { AWSIoT } from './AWSIot';
+export { MqttOverWS, mqttTopicMatch } from './MqttOverWS';

package/lib-esm/clients/iot.d.ts

@@ -0,0 +1 @@
+export { AWSIoT as PubSub, AWSIoTOptions as PubSubOptions } from '../Providers';

package/{src/internals/index.ts → lib-esm/clients/iot.js}

@@ -1,3 +1,3 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export { InternalPubSub, InternalPubSubClass } from './InternalPubSub';
+export { AWSIoT as PubSub } from '../Providers';

package/lib-esm/clients/mqtt.d.ts

@@ -0,0 +1 @@
+export { MqttOverWS as PubSub, MqttOptions as PubSubOptions, } from '../Providers';

package/lib-esm/{internals/index.js → clients/mqtt.js}

@@ -1,4 +1,3 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export { InternalPubSub, InternalPubSubClass } from './InternalPubSub';
-//# sourceMappingURL=index.js.map
+export { MqttOverWS as PubSub, } from '../Providers';

package/lib-esm/index.d.ts

@@ -1,4 +1,4 @@
-export { PubSub } from './PubSub';
 export { CONNECTION_STATE_CHANGE } from './Providers/constants';
 export { ConnectionState, CONTROL_MSG } from './types';
-export { AWSAppSyncRealTimeProvider, AWSAppSyncRealTimeProviderOptions, AWSIoTProvider, AWSIoTProviderOptions, AbstractPubSubProvider, MqttOverWSProvider, MqttProviderOptions, ObserverQuery, mqttTopicMatch, } from './Providers';
+export { mqttTopicMatch } from './Providers';
+export { PubSub, PubSubOptions } from './clients/iot';

package/lib-esm/index.js

@@ -1,7 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export { PubSub } from './PubSub';
 export { CONNECTION_STATE_CHANGE } from './Providers/constants';
 export { ConnectionState, CONTROL_MSG } from './types';
-export { AWSAppSyncRealTimeProvider, AWSIoTProvider, AbstractPubSubProvider, MqttOverWSProvider, mqttTopicMatch, } from './Providers';
-//# sourceMappingURL=index.js.map
+export { mqttTopicMatch } from './Providers';
+export { PubSub } from './clients/iot';