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

package/iot/packages.json

@@ -0,0 +1,7 @@
+{
+	"name": "@aws-amplify/pubsub/iot",
+	"main": "../lib/clients/iot.js",
+	"browser": "../lib-esm/clients/iot.js",
+	"module": "../lib-esm/clients/iot.js",
+	"typings": "../lib-esm/clients/iot.d.ts"
+}

package/lib/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/Providers/AWSIot.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWSIoT = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const MqttOverWS_1 = require("./MqttOverWS");
+const utils_1 = require("@aws-amplify/core/internals/utils");
+const core_1 = require("@aws-amplify/core");
+const SERVICE_NAME = 'iotdevicegateway';
+class AWSIoT extends MqttOverWS_1.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 (0, core_1.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 = utils_1.Signer.signUrl(endpoint, { access_key, secret_key, session_token }, serviceInfo);
+            return result;
+        })();
+    }
+}
+exports.AWSIoT = AWSIoT;

package/lib/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/Providers/MqttOverWS.js

@@ -0,0 +1,274 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MqttOverWS = exports.mqttTopicMatch = void 0;
+const tslib_1 = require("tslib");
+// @ts-ignore
+const Paho = tslib_1.__importStar(require("../vendor/paho-mqtt"));
+const rxjs_1 = require("rxjs");
+const PubSub_1 = require("./PubSub");
+const PubSub_2 = require("../types/PubSub");
+const core_1 = require("@aws-amplify/core");
+const utils_1 = require("@aws-amplify/core/internals/utils");
+const ConnectionStateMonitor_1 = require("../utils/ConnectionStateMonitor");
+const ReconnectionMonitor_1 = require("../utils/ReconnectionMonitor");
+const constants_1 = require("./constants");
+const logger = new core_1.ConsoleLogger('MqttOverWS');
+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;
+}
+exports.mqttTopicMatch = mqttTopicMatch;
+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) => {
+    core_1.Hub.dispatch('pubsub', payload, 'PubSub', constants_1.AMPLIFY_SYMBOL);
+};
+const topicSymbol = typeof Symbol !== 'undefined' ? Symbol('topic') : '@@topic';
+class MqttOverWS extends PubSub_1.AbstractPubSub {
+    constructor(options = {}) {
+        super({ ...options, clientId: options.clientId || (0, utils_1.amplifyUuid)() });
+        this._clientsQueue = new ClientsQueue();
+        this.connectionStateMonitor = new ConnectionStateMonitor_1.ConnectionStateMonitor();
+        this.reconnectionMonitor = new ReconnectionMonitor_1.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: constants_1.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 === PubSub_2.ConnectionState.ConnectionDisrupted) {
+                this.reconnectionMonitor.record(ReconnectionMonitor_1.ReconnectEvent.START_RECONNECT);
+            }
+            else if (connectionStateChange !== PubSub_2.ConnectionState.Connecting) {
+                // Trigger connected to halt reconnection attempts
+                this.reconnectionMonitor.record(ReconnectionMonitor_1.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(ConnectionStateMonitor_1.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(ConnectionStateMonitor_1.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(ConnectionStateMonitor_1.CONNECTION_CHANGE.CLOSED);
+                    resolve(false);
+                },
+            });
+        });
+        if (connected) {
+            this.connectionStateMonitor.record(ConnectionStateMonitor_1.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(ConnectionStateMonitor_1.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 rxjs_1.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 rxjs_1.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(ConnectionStateMonitor_1.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;
+            };
+        });
+    }
+}
+exports.MqttOverWS = MqttOverWS;

package/lib/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/Providers/PubSub.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractPubSub = void 0;
+const core_1 = require("@aws-amplify/core");
+const logger = new core_1.ConsoleLogger('AbstractPubSubProvider');
+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 };
+    }
+}
+exports.AbstractPubSub = AbstractPubSub;

package/lib/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/Providers/constants.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECONNECT_INTERVAL = exports.RECONNECT_DELAY = exports.DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT = exports.DEFAULT_KEEP_ALIVE_TIMEOUT = exports.START_ACK_TIMEOUT = exports.CONNECTION_INIT_TIMEOUT = exports.AWS_APPSYNC_REALTIME_HEADERS = exports.SOCKET_STATUS = exports.SUBSCRIPTION_STATUS = exports.MESSAGE_TYPES = exports.CONNECTION_STATE_CHANGE = exports.NON_RETRYABLE_CODES = exports.MAX_DELAY_MS = exports.AMPLIFY_SYMBOL = void 0;
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+var utils_1 = require("@aws-amplify/core/internals/utils");
+Object.defineProperty(exports, "AMPLIFY_SYMBOL", { enumerable: true, get: function () { return utils_1.AMPLIFY_SYMBOL; } });
 exports.MAX_DELAY_MS = 5000;
 exports.NON_RETRYABLE_CODES = [400, 401, 403];
 exports.CONNECTION_STATE_CHANGE = 'ConnectionStateChange';
@@ -70,9 +73,6 @@ var SOCKET_STATUS;
     SOCKET_STATUS[SOCKET_STATUS["READY"] = 1] = "READY";
     SOCKET_STATUS[SOCKET_STATUS["CONNECTING"] = 2] = "CONNECTING";
 })(SOCKET_STATUS = exports.SOCKET_STATUS || (exports.SOCKET_STATUS = {}));
-exports.AMPLIFY_SYMBOL = (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function'
-    ? Symbol.for('amplify_default')
-    : '@@amplify_default');
 exports.AWS_APPSYNC_REALTIME_HEADERS = {
     accept: 'application/json, text/javascript',
     'content-encoding': 'amz-1.0',
@@ -102,4 +102,3 @@ exports.RECONNECT_DELAY = 5 * 1000;
  * Default interval time in milleseconds between when reconnect is re-attempted
  */
 exports.RECONNECT_INTERVAL = 60 * 1000;
-//# sourceMappingURL=constants.js.map

package/lib/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/Providers/index.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mqttTopicMatch = exports.MqttOverWS = exports.AWSIoT = exports.AbstractPubSub = void 0;
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var PubSubProvider_1 = require("./PubSubProvider");
-exports.AbstractPubSubProvider = PubSubProvider_1.AbstractPubSubProvider;
-var AWSAppSyncRealTimeProvider_1 = require("./AWSAppSyncRealTimeProvider");
-exports.AWSAppSyncRealTimeProvider = AWSAppSyncRealTimeProvider_1.AWSAppSyncRealTimeProvider;
-var AWSIotProvider_1 = require("./AWSIotProvider");
-exports.AWSIoTProvider = AWSIotProvider_1.AWSIoTProvider;
-var MqttOverWSProvider_1 = require("./MqttOverWSProvider");
-exports.MqttOverWSProvider = MqttOverWSProvider_1.MqttOverWSProvider;
-exports.mqttTopicMatch = MqttOverWSProvider_1.mqttTopicMatch;
-//# sourceMappingURL=index.js.map
+var PubSub_1 = require("./PubSub");
+Object.defineProperty(exports, "AbstractPubSub", { enumerable: true, get: function () { return PubSub_1.AbstractPubSub; } });
+var AWSIot_1 = require("./AWSIot");
+Object.defineProperty(exports, "AWSIoT", { enumerable: true, get: function () { return AWSIot_1.AWSIoT; } });
+var MqttOverWS_1 = require("./MqttOverWS");
+Object.defineProperty(exports, "MqttOverWS", { enumerable: true, get: function () { return MqttOverWS_1.MqttOverWS; } });
+Object.defineProperty(exports, "mqttTopicMatch", { enumerable: true, get: function () { return MqttOverWS_1.mqttTopicMatch; } });

package/lib/clients/iot.d.ts

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

package/lib/clients/iot.js

@@ -0,0 +1,7 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubSub = void 0;
+var Providers_1 = require("../Providers");
+Object.defineProperty(exports, "PubSub", { enumerable: true, get: function () { return Providers_1.AWSIoT; } });

package/lib/clients/mqtt.d.ts

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

package/lib/clients/mqtt.js

@@ -0,0 +1,7 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubSub = void 0;
+var Providers_1 = require("../Providers");
+Object.defineProperty(exports, "PubSub", { enumerable: true, get: function () { return Providers_1.MqttOverWS; } });

package/lib/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/index.js

@@ -2,17 +2,13 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
-var PubSub_1 = require("./PubSub");
-exports.PubSub = PubSub_1.PubSub;
+exports.PubSub = exports.mqttTopicMatch = exports.CONTROL_MSG = exports.ConnectionState = exports.CONNECTION_STATE_CHANGE = void 0;
 var constants_1 = require("./Providers/constants");
-exports.CONNECTION_STATE_CHANGE = constants_1.CONNECTION_STATE_CHANGE;
+Object.defineProperty(exports, "CONNECTION_STATE_CHANGE", { enumerable: true, get: function () { return constants_1.CONNECTION_STATE_CHANGE; } });
 var types_1 = require("./types");
-exports.ConnectionState = types_1.ConnectionState;
-exports.CONTROL_MSG = types_1.CONTROL_MSG;
+Object.defineProperty(exports, "ConnectionState", { enumerable: true, get: function () { return types_1.ConnectionState; } });
+Object.defineProperty(exports, "CONTROL_MSG", { enumerable: true, get: function () { return types_1.CONTROL_MSG; } });
 var Providers_1 = require("./Providers");
-exports.AWSAppSyncRealTimeProvider = Providers_1.AWSAppSyncRealTimeProvider;
-exports.AWSIoTProvider = Providers_1.AWSIoTProvider;
-exports.AbstractPubSubProvider = Providers_1.AbstractPubSubProvider;
-exports.MqttOverWSProvider = Providers_1.MqttOverWSProvider;
-exports.mqttTopicMatch = Providers_1.mqttTopicMatch;
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, "mqttTopicMatch", { enumerable: true, get: function () { return Providers_1.mqttTopicMatch; } });
+var iot_1 = require("./clients/iot");
+Object.defineProperty(exports, "PubSub", { enumerable: true, get: function () { return iot_1.PubSub; } });