@aws-amplify/api-graphql 4.0.1-server-generate-client.1e317a1.0 → 4.0.1-ssr-api.df60e41.0

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

@@ -23,5 +23,5 @@ export declare enum ConnectionState {
     Disconnected = "Disconnected",
     ConnectedPendingKeepAlive = "ConnectedPendingKeepAlive"
 }
-export type PubSubContent = Record<string, unknown>;
-export type PubSubContentObserver = Observer<PubSubContent>;
+export declare type PubSubContent = Record<string, unknown>;
+export declare type PubSubContentObserver = Observer<PubSubContent>;

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

@@ -1,11 +1,10 @@
 import { AmplifyClassV6 } from '@aws-amplify/core';
-import { ModelTypes } from '@aws-amplify/amplify-api-next-types-alpha';
 import { Source, DocumentNode, GraphQLError } from 'graphql';
 export { OperationTypeNode } from 'graphql';
 import { Observable } from 'rxjs';
 import { GraphQLAuthMode, DocumentType } from '@aws-amplify/core/internals/utils';
+import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
 export { CONTROL_MSG, ConnectionState } from './PubSub';
-export { SelectionSet } from '@aws-amplify/amplify-api-next-types-alpha';
 /**
  * Loose/Unknown options for raw GraphQLAPICategory `graphql()`.
  */
@@ -27,10 +26,10 @@ export interface GraphQLResult<T = object> {
     };
 }
 declare const queryType: unique symbol;
-export type GraphQLQuery<T> = T & {
+export declare type GraphQLQuery<T> = T & {
     readonly [queryType]: 'query';
 };
-export type GraphQLSubscription<T> = T & {
+export declare type GraphQLSubscription<T> = T & {
     readonly [queryType]: 'subscription';
 };
 /**
@@ -54,14 +53,14 @@ export type GraphQLSubscription<T> = T & {
  *
  * This util simply makes related model properties optional recursively.
  */
-export type GraphQLReturnType<T> = T extends {} ? {
+export declare type GraphQLReturnType<T> = T extends {} ? {
     [K in keyof T]?: GraphQLReturnType<T[K]>;
 } : T;
 /**
  * Describes a paged list result from AppSync, which can either
  * live at the top query or property (e.g., related model) level.
  */
-type PagedList<T, TYPENAME> = {
+declare type PagedList<T, TYPENAME> = {
     __typename: TYPENAME;
     nextToken?: string | null | undefined;
     items: Array<T>;
@@ -74,13 +73,13 @@ type PagedList<T, TYPENAME> = {
  * array, this will only be the case when we also have errors,
  * which will then be *thrown*.
  */
-type WithListsFixed<T> = T extends PagedList<infer IT, infer NAME> ? PagedList<Exclude<IT, null | undefined>, NAME> : T extends {} ? {
+declare type WithListsFixed<T> = T extends PagedList<infer IT, infer NAME> ? PagedList<Exclude<IT, null | undefined>, NAME> : T extends {} ? {
     [K in keyof T]: WithListsFixed<T[K]>;
 } : T;
 /**
  * Returns an updated response type to always return a value.
  */
-type NeverEmpty<T> = {
+declare type NeverEmpty<T> = {
     [K in keyof T]-?: Exclude<WithListsFixed<T[K]>, undefined | null>;
 };
 /**
@@ -90,7 +89,7 @@ type NeverEmpty<T> = {
  * If empty members are present, there will also be errors present,
  * and the response will instead be *thrown*.
  */
-type FixedQueryResult<T> = Exclude<T[keyof T], null | undefined> extends PagedList<any, any> ? {
+declare type FixedQueryResult<T> = Exclude<T[keyof T], null | undefined> extends PagedList<any, any> ? {
     [K in keyof T]-?: WithListsFixed<Exclude<T[K], null | undefined>>;
 } : T;
 /**
@@ -113,7 +112,7 @@ type FixedQueryResult<T> = Exclude<T[keyof T], null | undefined> extends PagedLi
  * })
  * ```
  */
-export type GraphqlSubscriptionResult<T> = Observable<GraphqlSubscriptionMessage<T>>;
+export declare type GraphqlSubscriptionResult<T> = Observable<GraphqlSubscriptionMessage<T>>;
 /**
  * The shape of messages passed to `next()` from a graphql subscription. E.g.,
  *
@@ -130,7 +129,7 @@ export type GraphqlSubscriptionResult<T> = Observable<GraphqlSubscriptionMessage
  * })
  * ```
  */
-export type GraphqlSubscriptionMessage<T> = {
+export declare type GraphqlSubscriptionMessage<T> = {
     data: T;
 };
 export interface AWSAppSyncRealTimeProviderOptions {
@@ -145,7 +144,7 @@ export interface AWSAppSyncRealTimeProviderOptions {
         [key: string]: string;
     };
 }
-export type AWSAppSyncRealTimeProvider = {
+export declare type AWSAppSyncRealTimeProvider = {
     subscribe(options?: AWSAppSyncRealTimeProviderOptions): Observable<Record<string, unknown>>;
 };
 export declare enum GraphQLAuthError {
@@ -159,7 +158,7 @@ export declare enum GraphQLAuthError {
  * GraphQLSource or string, the type of the parameter for calling graphql.parse
  * @see: https://graphql.org/graphql-js/language/#parse
  */
-export type GraphQLOperation = Source | string;
+export declare type GraphQLOperation = Source | string;
 /**
  * API V6 `graphql({options})` type that can leverage branded graphql `query`
  * objects and fallback types.
@@ -181,17 +180,17 @@ export interface GraphQLOptionsV6<FALLBACK_TYPES = unknown, TYPED_GQL_STRING ext
  * Invoking code should either cast the result or use `?` and `!` operators to
  * navigate the result objects.
  */
-export type UnknownGraphQLResponse = Promise<GraphQLResult<any>> | GraphqlSubscriptionResult<any>;
+export declare type UnknownGraphQLResponse = Promise<GraphQLResult<any>> | GraphqlSubscriptionResult<any>;
 /**
  * The expected type for `variables` in a V6 `graphql()` operation with
  * respect to the given `FALLBACK_TYPES` and `TYPED_GQL_STRING`.
  */
-export type GraphQLVariablesV6<FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string> = TYPED_GQL_STRING extends GeneratedQuery<infer IN, any> ? IN : TYPED_GQL_STRING extends GeneratedMutation<infer IN, any> ? IN : TYPED_GQL_STRING extends GeneratedSubscription<infer IN, any> ? IN : FALLBACK_TYPES extends GraphQLOperationType<infer IN, any> ? IN : any;
+export declare type GraphQLVariablesV6<FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string> = TYPED_GQL_STRING extends GeneratedQuery<infer IN, any> ? IN : TYPED_GQL_STRING extends GeneratedMutation<infer IN, any> ? IN : TYPED_GQL_STRING extends GeneratedSubscription<infer IN, any> ? IN : FALLBACK_TYPES extends GraphQLOperationType<infer IN, any> ? IN : any;
 /**
  * The expected return type with respect to the given `FALLBACK_TYPE`
  * and `TYPED_GQL_STRING`.
  */
-export type GraphQLResponseV6<FALLBACK_TYPE = unknown, TYPED_GQL_STRING extends string = string> = TYPED_GQL_STRING extends GeneratedQuery<infer IN, infer QUERY_OUT> ? Promise<GraphQLResult<FixedQueryResult<QUERY_OUT>>> : TYPED_GQL_STRING extends GeneratedMutation<infer IN, infer MUTATION_OUT> ? Promise<GraphQLResult<NeverEmpty<MUTATION_OUT>>> : TYPED_GQL_STRING extends GeneratedSubscription<infer IN, infer SUB_OUT> ? GraphqlSubscriptionResult<NeverEmpty<SUB_OUT>> : FALLBACK_TYPE extends GraphQLQuery<infer T> ? Promise<GraphQLResult<FALLBACK_TYPE>> : FALLBACK_TYPE extends GraphQLSubscription<infer T> ? GraphqlSubscriptionResult<FALLBACK_TYPE> : FALLBACK_TYPE extends GraphQLOperationType<infer IN, infer CUSTOM_OUT> ? CUSTOM_OUT : UnknownGraphQLResponse;
+export declare type GraphQLResponseV6<FALLBACK_TYPE = unknown, TYPED_GQL_STRING extends string = string> = TYPED_GQL_STRING extends GeneratedQuery<infer IN, infer QUERY_OUT> ? Promise<GraphQLResult<FixedQueryResult<QUERY_OUT>>> : TYPED_GQL_STRING extends GeneratedMutation<infer IN, infer MUTATION_OUT> ? Promise<GraphQLResult<NeverEmpty<MUTATION_OUT>>> : TYPED_GQL_STRING extends GeneratedSubscription<infer IN, infer SUB_OUT> ? GraphqlSubscriptionResult<NeverEmpty<SUB_OUT>> : FALLBACK_TYPE extends GraphQLQuery<infer T> ? Promise<GraphQLResult<FALLBACK_TYPE>> : FALLBACK_TYPE extends GraphQLSubscription<infer T> ? GraphqlSubscriptionResult<FALLBACK_TYPE> : FALLBACK_TYPE extends GraphQLOperationType<infer IN, infer CUSTOM_OUT> ? CUSTOM_OUT : UnknownGraphQLResponse;
 /**
  * The shape customers can use to provide `T` to `graphql<T>()` to specify both
  * `IN` and `OUT` types (the type of `variables` and the return type, respectively).
@@ -210,7 +209,7 @@ export type GraphQLResponseV6<FALLBACK_TYPE = unknown, TYPED_GQL_STRING extends
  * })
  * ```
  */
-export type GraphQLOperationType<IN extends {}, OUT extends {}> = {
+export declare type GraphQLOperationType<IN extends {}, OUT extends {}> = {
     variables: IN;
     result: OUT;
 };
@@ -230,7 +229,7 @@ export type GraphQLOperationType<IN extends {}, OUT extends {}> = {
  * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
  * assign types to the `variables` and result objects.
  */
-export type GeneratedQuery<InputType, OutputType> = string & {
+export declare type GeneratedQuery<InputType, OutputType> = string & {
     __generatedQueryInput: InputType;
     __generatedQueryOutput: OutputType;
 };
@@ -250,7 +249,7 @@ export type GeneratedQuery<InputType, OutputType> = string & {
  * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
  * assign types to the `variables` and result objects.
  */
-export type GeneratedMutation<InputType, OutputType> = string & {
+export declare type GeneratedMutation<InputType, OutputType> = string & {
     __generatedMutationInput: InputType;
     __generatedMutationOutput: OutputType;
 };
@@ -270,23 +269,35 @@ export type GeneratedMutation<InputType, OutputType> = string & {
  * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
  * assign types to the `variables` and result objects.
  */
-export type GeneratedSubscription<InputType, OutputType> = string & {
+export declare type GeneratedSubscription<InputType, OutputType> = string & {
     __generatedSubscriptionInput: InputType;
     __generatedSubscriptionOutput: OutputType;
 };
-type FilteredKeys<T> = {
+declare type FilteredKeys<T> = {
     [P in keyof T]: T[P] extends never ? never : P;
 }[keyof T];
-type ExcludeNeverFields<O> = {
+declare type ExcludeNeverFields<O> = {
     [K in FilteredKeys<O>]: O[K];
 };
 export declare const __amplify: unique symbol;
-export type V6Client<T extends Record<any, any> = never> = ExcludeNeverFields<{
-    [__amplify]: AmplifyClassV6 | (() => Promise<AmplifyClassV6>);
-    graphql: <FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string>(options: GraphQLOptionsV6<FALLBACK_TYPES, TYPED_GQL_STRING>, additionalHeaders?: {
-        [key: string]: string;
-    } | undefined) => GraphQLResponseV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+/**
+ * TODO: Refactor these 2. Pull out `graphQL` into its own type
+ */
+export declare type V6Client<T extends Record<any, any> = never> = ExcludeNeverFields<{
+    [__amplify]: AmplifyClassV6;
+    graphql: GraphQLMethod;
+    cancel: (promise: Promise<any>, message?: string) => boolean;
+    isCancelError: (error: any) => boolean;
+}>;
+export declare type V6ClientSSR<T extends Record<any, any> = never> = ExcludeNeverFields<{
+    [__amplify]: AmplifyClassV6;
+    graphql: GraphQLMethodSSR;
     cancel: (promise: Promise<any>, message?: string) => boolean;
     isCancelError: (error: any) => boolean;
-    models: ModelTypes<T>;
 }>;
+export declare type GraphQLMethod = <FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string>(options: GraphQLOptionsV6<FALLBACK_TYPES, TYPED_GQL_STRING>, additionalHeaders?: {
+    [key: string]: string;
+} | undefined) => GraphQLResponseV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+export declare type GraphQLMethodSSR = <FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string>(contextSpec: AmplifyServer.ContextSpec, options: GraphQLOptionsV6<FALLBACK_TYPES, TYPED_GQL_STRING>, additionalHeaders?: {
+    [key: string]: string;
+} | undefined) => GraphQLResponseV6<FALLBACK_TYPES, TYPED_GQL_STRING>;

package/lib-esm/types/index.js

@@ -7,4 +7,4 @@ export var GraphQLAuthError;
     GraphQLAuthError["NO_FEDERATED_JWT"] = "No federated jwt";
     GraphQLAuthError["NO_AUTH_TOKEN"] = "No auth token specified";
 })(GraphQLAuthError || (GraphQLAuthError = {}));
-export var __amplify = Symbol('amplify');
+export const __amplify = Symbol('amplify');

package/lib-esm/utils/ConnectionStateMonitor.d.ts

@@ -1,8 +1,8 @@
 import { Observable } from 'rxjs';
 import { ConnectionState } from '../types/PubSub';
-type LinkedConnectionState = 'connected' | 'disconnected';
-type LinkedHealthState = 'healthy' | 'unhealthy';
-type LinkedConnectionStates = {
+declare type LinkedConnectionState = 'connected' | 'disconnected';
+declare type LinkedHealthState = 'healthy' | 'unhealthy';
+declare type LinkedConnectionStates = {
     networkState: LinkedConnectionState;
     connectionState: LinkedConnectionState | 'connecting';
     intendedConnectionState: LinkedConnectionState;

package/lib-esm/utils/ConnectionStateMonitor.js

@@ -1,10 +1,9 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __assign } from "tslib";
 import { Observable, map, filter } from 'rxjs';
 import { ConnectionState } from '../types/PubSub';
 import { ReachabilityMonitor } from './ReachabilityMonitor';
-export var CONNECTION_CHANGE = {
+export const CONNECTION_CHANGE = {
     KEEP_ALIVE_MISSED: { keepAliveState: 'unhealthy' },
     KEEP_ALIVE: { keepAliveState: 'healthy' },
     CONNECTION_ESTABLISHED: { connectionState: 'connected' },
@@ -21,9 +20,8 @@ export var CONNECTION_CHANGE = {
     ONLINE: { networkState: 'connected' },
     OFFLINE: { networkState: 'disconnected' },
 };
-var ConnectionStateMonitor = /** @class */ (function () {
-    function ConnectionStateMonitor() {
-        var _this = this;
+export class ConnectionStateMonitor {
+    constructor() {
         this._networkMonitoringSubscription = undefined;
         this._linkedConnectionState = {
             networkState: 'connected',
@@ -32,73 +30,61 @@ var ConnectionStateMonitor = /** @class */ (function () {
             keepAliveState: 'healthy',
         };
         // Attempt to update the state with the current actual network state
-        this._initialNetworkStateSubscription = ReachabilityMonitor().subscribe(function (_a) {
-            var _b;
-            var online = _a.online;
-            _this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
-            (_b = _this._initialNetworkStateSubscription) === null || _b === void 0 ? void 0 : _b.unsubscribe();
+        this._initialNetworkStateSubscription = ReachabilityMonitor().subscribe(({ online }) => {
+            this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
+            this._initialNetworkStateSubscription?.unsubscribe();
         });
         this._linkedConnectionStateObservable =
-            new Observable(function (connectionStateObserver) {
-                connectionStateObserver.next(_this._linkedConnectionState);
-                _this._linkedConnectionStateObserver = connectionStateObserver;
+            new Observable(connectionStateObserver => {
+                connectionStateObserver.next(this._linkedConnectionState);
+                this._linkedConnectionStateObserver = connectionStateObserver;
             });
     }
     /**
      * Turn network state monitoring on if it isn't on already
      */
-    ConnectionStateMonitor.prototype.enableNetworkMonitoring = function () {
-        var _this = this;
-        var _a;
+    enableNetworkMonitoring() {
         // If no initial network state was discovered, stop trying
-        (_a = this._initialNetworkStateSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this._initialNetworkStateSubscription?.unsubscribe();
         // Maintain the network state based on the reachability monitor
         if (this._networkMonitoringSubscription === undefined) {
-            this._networkMonitoringSubscription = ReachabilityMonitor().subscribe(function (_a) {
-                var online = _a.online;
-                _this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
+            this._networkMonitoringSubscription = ReachabilityMonitor().subscribe(({ online }) => {
+                this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
             });
         }
-    };
+    }
     /**
      * Turn network state monitoring off if it isn't off already
      */
-    ConnectionStateMonitor.prototype.disableNetworkMonitoring = function () {
-        var _a;
-        (_a = this._networkMonitoringSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    disableNetworkMonitoring() {
+        this._networkMonitoringSubscription?.unsubscribe();
         this._networkMonitoringSubscription = undefined;
-    };
-    Object.defineProperty(ConnectionStateMonitor.prototype, "connectionStateObservable", {
-        /**
-         * Get the observable that allows us to monitor the connection state
-         *
-         * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
-         */
-        get: function () {
-            var _this = this;
-            var previous;
-            // The linked state aggregates state changes to any of the network, connection,
-            // intendedConnection and keepAliveHealth. Some states will change these independent
-            // states without changing the overall connection state.
-            // After translating from linked states to ConnectionState, then remove any duplicates
-            return this._linkedConnectionStateObservable
-                .pipe(map(function (value) {
-                return _this.connectionStatesTranslator(value);
-            }))
-                .pipe(filter(function (current) {
-                var toInclude = current !== previous;
-                previous = current;
-                return toInclude;
-            }));
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    /**
+     * Get the observable that allows us to monitor the connection state
+     *
+     * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
+     */
+    get connectionStateObservable() {
+        let previous;
+        // The linked state aggregates state changes to any of the network, connection,
+        // intendedConnection and keepAliveHealth. Some states will change these independent
+        // states without changing the overall connection state.
+        // After translating from linked states to ConnectionState, then remove any duplicates
+        return this._linkedConnectionStateObservable
+            .pipe(map(value => {
+            return this.connectionStatesTranslator(value);
+        }))
+            .pipe(filter(current => {
+            const toInclude = current !== previous;
+            previous = current;
+            return toInclude;
+        }));
+    }
     /*
      * Updates local connection state and emits the full state to the observer.
      */
-    ConnectionStateMonitor.prototype.record = function (statusUpdates) {
-        var _a;
+    record(statusUpdates) {
         // Maintain the network monitor
         if (statusUpdates.intendedConnectionState === 'connected') {
             this.enableNetworkMonitoring();
@@ -107,15 +93,17 @@ var ConnectionStateMonitor = /** @class */ (function () {
             this.disableNetworkMonitoring();
         }
         // Maintain the socket state
-        var newSocketStatus = __assign(__assign({}, this._linkedConnectionState), statusUpdates);
-        this._linkedConnectionState = __assign({}, newSocketStatus);
-        (_a = this._linkedConnectionStateObserver) === null || _a === void 0 ? void 0 : _a.next(this._linkedConnectionState);
-    };
+        const newSocketStatus = {
+            ...this._linkedConnectionState,
+            ...statusUpdates,
+        };
+        this._linkedConnectionState = { ...newSocketStatus };
+        this._linkedConnectionStateObserver?.next(this._linkedConnectionState);
+    }
     /*
      * Translate the ConnectionState structure into a specific ConnectionState string literal union
      */
-    ConnectionStateMonitor.prototype.connectionStatesTranslator = function (_a) {
-        var connectionState = _a.connectionState, networkState = _a.networkState, intendedConnectionState = _a.intendedConnectionState, keepAliveState = _a.keepAliveState;
+    connectionStatesTranslator({ connectionState, networkState, intendedConnectionState, keepAliveState, }) {
         if (connectionState === 'connected' && networkState === 'disconnected')
             return ConnectionState.ConnectedPendingNetwork;
         if (connectionState === 'connected' &&
@@ -136,7 +124,5 @@ var ConnectionStateMonitor = /** @class */ (function () {
         if (connectionState === 'disconnected')
             return ConnectionState.Disconnected;
         return ConnectionState.Connected;
-    };
-    return ConnectionStateMonitor;
-}());
-export { ConnectionStateMonitor };
+    }
+}

package/lib-esm/utils/ReachabilityMonitor/index.d.ts

@@ -1 +1 @@
-export declare const ReachabilityMonitor: () => import("rxjs").Observable<import("@aws-amplify/core/lib-esm/Reachability/types").NetworkStatus>;
+export declare const ReachabilityMonitor: () => any;

package/lib-esm/utils/ReachabilityMonitor/index.js

@@ -1,4 +1,4 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { Reachability } from '@aws-amplify/core/internals/utils';
-export var ReachabilityMonitor = function () { return new Reachability().networkMonitor(); };
+export const ReachabilityMonitor = () => new Reachability().networkMonitor();

package/lib-esm/utils/ReachabilityMonitor/index.native.d.ts

@@ -1 +1 @@
-export declare const ReachabilityMonitor: () => import("rxjs").Observable<import("@aws-amplify/core/lib-esm/Reachability/types").NetworkStatus>;
+export declare const ReachabilityMonitor: () => any;

package/lib-esm/utils/ReachabilityMonitor/index.native.js

@@ -2,6 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0
 import { Reachability } from '@aws-amplify/core/internals/utils';
 import { default as NetInfo } from '@react-native-community/netinfo';
-export var ReachabilityMonitor = function () {
-    return new Reachability().networkMonitor(NetInfo);
-};
+export const ReachabilityMonitor = () => new Reachability().networkMonitor(NetInfo);

package/lib-esm/utils/ReconnectionMonitor.js

@@ -10,31 +10,30 @@ export 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() {
+export 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();
                     }, RECONNECT_INTERVAL);
                 }, RECONNECT_DELAY);
             }
@@ -49,22 +48,18 @@ 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;
-}());
-export { ReconnectionMonitor };
+    }
+}

package/lib-esm/utils/errors/APIError.js

@@ -1,20 +1,15 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __extends } from "tslib";
 import { AmplifyError, } from '@aws-amplify/core/internals/utils';
 /**
  * @internal
  */
-var APIError = /** @class */ (function (_super) {
-    __extends(APIError, _super);
-    function APIError(params) {
-        var _this = _super.call(this, params) || this;
+export class APIError extends AmplifyError {
+    constructor(params) {
+        super(params);
         // Hack for making the custom error class work when transpiled to es5
         // TODO: Delete the following 2 lines after we change the build target to >= es2015
-        _this.constructor = APIError;
-        Object.setPrototypeOf(_this, APIError.prototype);
-        return _this;
+        this.constructor = APIError;
+        Object.setPrototypeOf(this, APIError.prototype);
     }
-    return APIError;
-}(AmplifyError));
-export { APIError };
+}

package/lib-esm/utils/errors/assertValidationError.js

@@ -6,8 +6,8 @@ import { validationErrorMap } from './validation';
  * @internal
  */
 export function assertValidationError(assertion, name) {
-    var _a = validationErrorMap[name], message = _a.message, recoverySuggestion = _a.recoverySuggestion;
+    const { message, recoverySuggestion } = validationErrorMap[name];
     if (!assertion) {
-        throw new APIError({ name: name, message: message, recoverySuggestion: recoverySuggestion });
+        throw new APIError({ name, message, recoverySuggestion });
     }
 }

package/lib-esm/utils/errors/validation.js

@@ -1,24 +1,23 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var _a;
 export var APIValidationErrorCode;
 (function (APIValidationErrorCode) {
     APIValidationErrorCode["NoAuthSession"] = "NoAuthSession";
     APIValidationErrorCode["NoRegion"] = "NoRegion";
     APIValidationErrorCode["NoCustomEndpoint"] = "NoCustomEndpoint";
 })(APIValidationErrorCode || (APIValidationErrorCode = {}));
-export var validationErrorMap = (_a = {},
-    _a[APIValidationErrorCode.NoAuthSession] = {
+export const validationErrorMap = {
+    [APIValidationErrorCode.NoAuthSession]: {
         message: 'Auth session should not be empty.',
     },
     // TODO: re-enable when working in all test environments:
     // [APIValidationErrorCode.NoEndpoint]: {
     // 	message: 'Missing endpoint',
     // },
-    _a[APIValidationErrorCode.NoRegion] = {
+    [APIValidationErrorCode.NoRegion]: {
         message: 'Missing region.',
     },
-    _a[APIValidationErrorCode.NoCustomEndpoint] = {
+    [APIValidationErrorCode.NoCustomEndpoint]: {
         message: 'Custom endpoint region is present without custom endpoint.',
     },
-    _a);
+};

package/lib-esm/utils/resolveConfig.d.ts

@@ -6,7 +6,7 @@ export declare const resolveConfig: (amplify: AmplifyClassV6) => {
     apiKey: string | undefined;
     customEndpoint: string | undefined;
     customEndpointRegion: string | undefined;
-    defaultAuthMode: import("@aws-amplify/core/lib-esm/libraryUtils").GraphQLAuthMode | undefined;
+    defaultAuthMode: "apiKey" | "oidc" | "userPool" | "iam" | "lambda" | "none" | undefined;
     endpoint: string | undefined;
     region: string | undefined;
 };

package/lib-esm/utils/resolveConfig.js

@@ -4,18 +4,17 @@ import { APIValidationErrorCode, assertValidationError } from './errors';
 /**
  * @internal
  */
-export var resolveConfig = function (amplify) {
-    var _a, _b;
-    var _c = (_b = (_a = amplify.getConfig().API) === null || _a === void 0 ? void 0 : _a.GraphQL) !== null && _b !== void 0 ? _b : {}, apiKey = _c.apiKey, customEndpoint = _c.customEndpoint, customEndpointRegion = _c.customEndpointRegion, defaultAuthMode = _c.defaultAuthMode, endpoint = _c.endpoint, region = _c.region;
+export const resolveConfig = (amplify) => {
+    const { apiKey, customEndpoint, customEndpointRegion, defaultAuthMode, endpoint, region, } = amplify.getConfig().API?.GraphQL ?? {};
     // TODO: re-enable when working in all test environments:
     // assertValidationError(!!endpoint, APIValidationErrorCode.NoEndpoint);
     assertValidationError(!(!customEndpoint && customEndpointRegion), APIValidationErrorCode.NoCustomEndpoint);
     return {
-        apiKey: apiKey,
-        customEndpoint: customEndpoint,
-        customEndpointRegion: customEndpointRegion,
-        defaultAuthMode: defaultAuthMode,
-        endpoint: endpoint,
-        region: region,
+        apiKey,
+        customEndpoint,
+        customEndpointRegion,
+        defaultAuthMode,
+        endpoint,
+        region,
     };
 };

package/lib-esm/utils/resolveLibraryOptions.d.ts

@@ -6,6 +6,6 @@ export declare const resolveLibraryOptions: (amplify: AmplifyClassV6) => {
     headers: ((options: {
         query: string;
         variables?: Record<string, import("@aws-amplify/core/lib-esm/libraryUtils").DocumentType> | undefined;
-    }) => Promise<import("@aws-amplify/core/lib-esm/clients").Headers>) | undefined;
+    }) => Promise<Record<string, string>>) | undefined;
     withCredentials: boolean | undefined;
 };

package/lib-esm/utils/resolveLibraryOptions.js

@@ -3,9 +3,8 @@
 /**
  * @internal
  */
-export var resolveLibraryOptions = function (amplify) {
-    var _a, _b, _c, _d, _e, _f;
-    var headers = (_c = (_b = (_a = amplify.libraryOptions) === null || _a === void 0 ? void 0 : _a.API) === null || _b === void 0 ? void 0 : _b.GraphQL) === null || _c === void 0 ? void 0 : _c.headers;
-    var withCredentials = (_f = (_e = (_d = amplify.libraryOptions) === null || _d === void 0 ? void 0 : _d.API) === null || _e === void 0 ? void 0 : _e.GraphQL) === null || _f === void 0 ? void 0 : _f.withCredentials;
-    return { headers: headers, withCredentials: withCredentials };
+export const resolveLibraryOptions = (amplify) => {
+    const headers = amplify.libraryOptions?.API?.GraphQL?.headers;
+    const withCredentials = amplify.libraryOptions?.API?.GraphQL?.withCredentials;
+    return { headers, withCredentials };
 };